home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / gnu / para.lha / para / para.el < prev    next >
Text File  |  1991-04-18  |  102KB  |  2,753 lines
  1. ;;; para-mode
  2.  
  3. ;;; Copyright (C) 1989, 1990, 1991 Free Software Foundation
  4. ;;; ALPHA test version; not for widespead distribution.
  5. ;;; Robert J. Chassell
  6. ;;; bugs to bob@ai.mit.edu
  7. ;;;
  8. ;;; Known bug: para-add-node deletes the detailed part of a master
  9. ;;;            menu if the added node is a chapter.  Will need to
  10. ;;;            modify para-insert-update-pointers-&-menu, using ideas
  11. ;;;            from para-make-master-menu.
  12. ;;;
  13. ;;; Change Log ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  14. ;;;
  15. ;;; Version 0.27
  16. ;;; 17 apr 91 - Defined `para-main-menu-buffer-name' global variable
  17. ;;;             with default value of empty string.  `para-xref' now
  18. ;;;             works even without listing the main menu.
  19. ;;;
  20. ;;; Version 0.26
  21. ;;;  5 Apr 91 - Added `para-scroll-down' (bound to DEL); works
  22. ;;;             parallel to `para-scroll-up' (bound to SPC).
  23. ;;;
  24. ;;; Version 0.25
  25. ;;;  3 Apr 91 - `para-make-file' rewritten.
  26. ;;;
  27. ;;; Version 0.24
  28. ;;; 27 Mar 91 - Indexing commands defined.
  29. ;;;
  30. ;;; Version 0.23
  31. ;;; 25 Mar 91 - `para-menu-explode' defined; forgot to include it before.
  32. ;;;              `para-preceding-node-type' returns "top" if in top node
  33. ;;;              and current node if on node line.  `para-add-node'
  34. ;;;              changed to work with new `para-preceding-node-type'.
  35. ;;;              `para-search' defined; searches forward for regexp.
  36. ;;;
  37. ;;; Version 0.22
  38. ;;; 19 Mar 91 - Rewrote `para-extract-menu-name' to use
  39. ;;;             `para-extract-menu-node-name' which returns nodename.
  40. ;;;             This makes mouse menu selection possible in X.
  41. ;;;
  42. ;;; Version 0.21
  43. ;;;  4 Mar 91 - Added `para-history' to `para-goto' when using tag table.
  44. ;;;             Added `para-tagify' and its utility function,
  45. ;;;             `para-clean-name' so tag tables can be made.
  46. ;;;             Removed infinite loop from `para-last'.
  47. ;;;             Added new movement commands: para-scroll-up,
  48. ;;;             para-top-node, para-final,
  49. ;;;             para-goto-previous-node-in-sequence,
  50. ;;;             para-goto-next-node-in-sequence
  51. ;;;
  52. ;;; Version 0.20
  53. ;;; 26 Feb 91 - Rewrote much of code.  No longer dependent on `infosim.el'
  54. ;;;
  55. ;;; Version 0.10
  56. ;;; 12 Feb 91 - Revised all keybindings to be consistent with Texinfo mode.
  57. ;;;             Merged bug fixes and new menu and file finding commands.
  58. ;;;             Revised `para.texinfo' doc file.
  59. ;;;
  60. ;;; <other change logs removed>
  61. ;;;
  62. ;;; Version 0.01
  63. ;;; 17 Dec 1989 - 
  64. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  65.  
  66.  
  67. ;;; What is Para mode?
  68.  
  69. ;;; Para mode is an extension of Texinfo and Infosim mode that
  70. ;;; includes some hypertext-like features.  I chose the name `Para
  71. ;;; mode' (from the Greek word for `beyond') to suggest that it is
  72. ;;; `beyond' Texinfo mode or Infosim mode, but not to claim that it is
  73. ;;; a full-fledged hypertext system.  Eventually, Para mode should be
  74. ;;; merged into Texinfo mode.
  75.  
  76. ;;; Para mode was inspired by Infosim mode, which was written by
  77. ;;; Matthew P Wiener.
  78.  
  79. ;;; This code is in `alpha-test'.  Please do not distribute it widely.
  80.  
  81.  
  82. ;;; Summary list of Para mode commands
  83. ; 
  84. ;     C-c C-p f       para-make-file
  85. ;     C-c C-p C-q     para-quit
  86. ; 
  87. ;     C-c C-p a       para-add-node
  88. ;     C-c C-p i       para-insert-menu
  89. ;     C-c C-p e       para-menu-explode
  90. ;     C-c C-p n       para-narrow-to-node
  91. ; 
  92. ;     C-c C-p m       para-make-master-menu           (primary updating 
  93. ;                                                      command)
  94. ; 
  95. ;     C-c C-p t       para-tagify                     (for faster movement
  96. ;                                                      in large files)
  97. ;
  98. ; Directory listing and related movement commands
  99. ; 
  100. ;     C-c C-p d       para-directory
  101. ;     C-c C-p l       para-list-visited-nodes
  102. ; 
  103. ;     C-c C-p C-m     para-main-menu-goto-node        (these commands parallel
  104. ;     C-c C-p C-m     para-goto-visited-node           each other in 
  105. ;     C-c C-p C-m     para-menu                        different buffers)
  106. ; 
  107. ; Other movement commands
  108. ;
  109. ;     C-c C-p C-b     para-beginning                   (beginning of file)
  110. ;     C-c C-p C-<     para-top-node
  111. ;     C-c C-p C->     para-final                       (last node in file)
  112. ;
  113. ;     C-c C-p C-u     para-up
  114. ;     C-c C-p C-p     para-prev
  115. ;     C-c C-p C-[     para-goto-previous-node-in-sequence
  116. ;     C-c C-p C-n     para-next
  117. ;     C-c C-p C-]     para-goto-next-node-in-sequence
  118. ;     C-c C-p RET     para-menu        (i.e., key chord is `C-p C-c C-m')
  119. ;     C-c C-p C-l     para-last
  120. ;     C-c C-p C-g     para-goto-node
  121. ;     C-c C-p C-f     para-follow
  122. ; 
  123. ;     C-c C-p 1       para-menu-1      go to the node of the first menu 
  124. ;                                         item, etc., up to `9'
  125. ; 
  126. ;     C-c C-p C-s     para-search
  127. ; 
  128. ; Cross reference creation commands
  129. ;
  130. ;     C-c C-p r       para-main-menu-buffer-xref      (these commands parallel
  131. ;     C-c C-p r       para-visited-xref                each other in 
  132. ;     C-c C-p r       para-xref                        different buffers)
  133. ;
  134. ; Indexing commands
  135. ;
  136. ;     C-c C-x c       para-index-concept             (these commands insert
  137. ;     C-c C-x f       para-index-function             index entries)
  138. ;     C-c C-x k       para-index-keystroke
  139. ;     C-c C-x p       para-index-program
  140. ;     C-c C-x t       para-index-datatype
  141. ;     C-c C-x v       para-index-variable
  142. ;
  143. ;     C-c C-x x       para-insert-index              (cause @printindex
  144. ;                                                     to insert indices)
  145. ; 
  146. ; Texinfo updating commands  (other Texinfo commands work also) 
  147. ;
  148. ;     C-c C-u C-e     texinfo-every-node-update
  149. ;     C-c C-u C-a     texinfo-all-menus-update
  150. ;
  151.  
  152. ;;; Load files
  153.  
  154. ;;; The standard Emacs 18 distribution loads version 1 Texinfo files.
  155. ;;; Para mode requires version 2 Texinfo files.
  156.  
  157. ;;; To ensure that you load version 2 Texinfo files, you must list the
  158. ;;; directory containing the version 2 Texinfo files in your load path
  159. ;;; before you list the directory containing the version 1 files.  You
  160. ;;; could do this by setting your load path in your `.emacs' file in a
  161. ;;; manner somewhat similar to the following: (If the first element of
  162. ;;; the load path is nil, it signifies the current directory.)
  163.  
  164. ;;; (setq load-path '(nil "/u/texinfo2" "/u/para" "/usr/local/lib/emacs/lisp")
  165.  
  166. ;;; After setting the load path, you may load the necessary Texinfo
  167. ;;; files the following commands:
  168.  
  169. ;(load "texinfo")
  170. ;(load "texnfo-upd")
  171.  
  172. ;;; Or you may use `require' commands in this `para.el' file, which is
  173. ;;; more elegant:
  174.  
  175. (require 'texinfo)
  176. (require 'texnfo-upd)
  177.  
  178. (message "Loading Para mode ... ")
  179. ;;; (Place `provide' at end of file.)
  180.  
  181.  
  182. ;;; Syntax table
  183.  
  184. (defvar para-mode-syntax-table nil)
  185.  
  186. (if para-mode-syntax-table nil          ; based in Infosim mode
  187.   (setq para-mode-syntax-table (make-syntax-table))
  188.   (modify-syntax-entry ?\" " " para-mode-syntax-table)
  189.   (modify-syntax-entry ?\\ " " para-mode-syntax-table)
  190.   (modify-syntax-entry ?@ "\\" para-mode-syntax-table)
  191.   (modify-syntax-entry ?\^q "\\" para-mode-syntax-table)
  192.   (modify-syntax-entry ?\[ "(]" para-mode-syntax-table)
  193.   (modify-syntax-entry ?\] ")[" para-mode-syntax-table)
  194.   (modify-syntax-entry ?{ "(}" para-mode-syntax-table)
  195.   (modify-syntax-entry ?} "){" para-mode-syntax-table)
  196.   (modify-syntax-entry ?\' "w" para-mode-syntax-table))
  197.  
  198.  
  199. ;;; Keybindings
  200.  
  201. ;;; Keybindings are compatible with Texinfo mode,
  202. ;;; which are defined in `texinfo.el'.
  203.  
  204.     ; TeX commands              prefix key: `C-c C-t'
  205.     ; Elisp formatting commands prefix key: `C-c C-e'
  206.     ; C code commands           prefix key: `C-c C-m'
  207.     ; Updating commands         prefix key: `C-c C-u'
  208.     ; String insertion commands prefix key: `C-c C-c'
  209.  
  210.     ; Para indexing commands    prefix key: `C-c C-x'
  211.     ; Para mode general         prefix key: `C-c C-p'
  212.  
  213. ;;; Para mode keys should use a `C-c C-p' prefix, except for
  214. ;;; indexing commands and those keys that have special
  215. ;;; meaning only in the upper left-hand corner of the window, or in
  216. ;;; read-only buffers.
  217.  
  218. ;;; The Para mode keybinding convention is that movement commands use
  219. ;;; only control keys and insertion commands use prefix plus regular
  220. ;;; key, like the Texinfo string insertion commands.
  221.  
  222. (defvar para-mode-map nil "Keymap for Para mode.")
  223.  
  224. ;;; !!! remove this setq after finishing testing!
  225. (setq para-mode-map nil)
  226.  
  227. (if para-mode-map nil
  228.  
  229. ;;; Provide Texinfo mode keybindings;
  230. ;;; must be from Texinfo version 2.
  231.   (setq para-mode-map (copy-keymap texinfo-mode-map))
  232.  
  233.   (define-key para-mode-map "\t" 'tab-to-tab-stop)
  234.  
  235. ;;; The following keybindings apply only when the cursor is in the
  236. ;;; upper left hand corner of the window.
  237.   (define-key para-mode-map " " 'para-@)
  238.   (define-key para-mode-map "0" 'para-@)
  239.   (define-key para-mode-map "1" 'para-@)
  240.   (define-key para-mode-map "2" 'para-@)
  241.   (define-key para-mode-map "3" 'para-@)
  242.   (define-key para-mode-map "4" 'para-@)
  243.   (define-key para-mode-map "5" 'para-@)
  244.   (define-key para-mode-map "6" 'para-@)
  245.   (define-key para-mode-map "7" 'para-@)
  246.   (define-key para-mode-map "8" 'para-@)
  247.   (define-key para-mode-map "9" 'para-@)
  248.   (define-key para-mode-map "b" 'para-@)
  249.   (define-key para-mode-map "d" 'para-@)
  250.   (define-key para-mode-map "f" 'para-@)
  251.   (define-key para-mode-map "g" 'para-@)
  252.   (define-key para-mode-map "l" 'para-@)
  253.   (define-key para-mode-map "m" 'para-@)
  254.   (define-key para-mode-map "n" 'para-@)
  255.   (define-key para-mode-map "p" 'para-@)
  256.   (define-key para-mode-map "q" 'para-@)
  257.   (define-key para-mode-map "s" 'para-@)
  258.   (define-key para-mode-map "u" 'para-@)
  259.   (define-key para-mode-map "<" 'para-@)
  260.   (define-key para-mode-map ">" 'para-@)
  261.   (define-key para-mode-map "[" 'para-@)
  262.   (define-key para-mode-map "]" 'para-@)
  263.   (define-key para-mode-map "\C-?" 'para-@)
  264.  
  265. ;;; `C-c C-p' is the general prefix key for Para mode commands.
  266.  
  267. ;;; Go to first, second, third, etc. node in menu
  268.   (define-key para-mode-map "\C-c\C-p1" 'para-menu-1)
  269.   (define-key para-mode-map "\C-c\C-p2" 'para-menu-2)
  270.   (define-key para-mode-map "\C-c\C-p3" 'para-menu-3)
  271.   (define-key para-mode-map "\C-c\C-p4" 'para-menu-4)
  272.   (define-key para-mode-map "\C-c\C-p5" 'para-menu-5)
  273.   (define-key para-mode-map "\C-c\C-p6" 'para-menu-6)
  274.   (define-key para-mode-map "\C-c\C-p7" 'para-menu-7)
  275.   (define-key para-mode-map "\C-c\C-p8" 'para-menu-8)
  276.   (define-key para-mode-map "\C-c\C-p9" 'para-menu-9)
  277.   (define-key para-mode-map "\C-c\C-p0" 'para-menu-1x)
  278.  
  279. ;;; Para mode movement keybindings -- use only control characters:
  280.   (define-key para-mode-map "\C-c\C-p\C-b" 'para-beginning)
  281.   (define-key para-mode-map "\C-c\C-p\C-f" 'para-follow)
  282.   (define-key para-mode-map "\C-c\C-p\C-g" 'para-goto-node)
  283.   (define-key para-mode-map "\C-c\C-p\C-l" 'para-last)
  284.   (define-key para-mode-map "\C-c\C-p\C-m" 'para-menu)
  285.   (define-key para-mode-map "\C-c\C-p\C-n" 'para-next)
  286.   (define-key para-mode-map "\C-c\C-p\C-p" 'para-prev)
  287.   (define-key para-mode-map "\C-c\C-p\C-q" 'para-quit)
  288.   (define-key para-mode-map "\C-c\C-p\C-s" 'para-search)
  289.   (define-key para-mode-map "\C-c\C-p\C-u" 'para-up)
  290.   (define-key para-mode-map "\C-c\C-p\C-<" 'para-top-node)
  291.   (define-key para-mode-map "\C-c\C-p\C->" 'para-final)
  292.   (define-key para-mode-map "\C-c\C-p\C-]"
  293.     'para-goto-next-node-in-sequence)
  294.   (define-key para-mode-map "\C-c\C-p\C-["
  295.     'para-goto-previous-node-in-sequence)
  296.  
  297. ;;; Keybindings that create or change a buffer use prefix plus key.
  298.  
  299. ;;; Para mode keybindings for commands to create or change the Para
  300. ;;; mode file:
  301.  
  302.   (define-key para-mode-map "\C-c\C-pa" 'para-add-node)
  303.   (define-key para-mode-map "\C-c\C-pe" 'para-menu-explode)
  304.   (define-key para-mode-map "\C-c\C-pf" 'para-make-file)
  305.   (define-key para-mode-map "\C-c\C-pi" 'para-insert-menu)
  306.   (define-key para-mode-map "\C-c\C-pm" 'para-make-master-menu)
  307.   (define-key para-mode-map "\C-c\C-pr" 'para-xref)
  308.   (define-key para-mode-map "\C-c\C-pt" 'para-tagify)
  309.  
  310. ;;; Para mode keybindings for commands to create a temporary buffer
  311. ;;; listing all the nodes:
  312.  
  313.   (define-key para-mode-map "\C-c\C-pd" 'para-directory)
  314.   (define-key para-mode-map "\C-c\C-pl" 'para-list-visited-nodes)
  315.  
  316. ;;; Exception to C-c C-p keybinding conventions:
  317.   (define-key para-mode-map "\C-c\C-pn" 'para-narrow-to-node)
  318.  
  319. ;;; `C-c C-x' is the prefix key for Para indexing.
  320.  
  321.   (define-key para-mode-map "\C-c\C-xc" 'para-index-concept)
  322.   (define-key para-mode-map "\C-c\C-xf" 'para-index-function)
  323.   (define-key para-mode-map "\C-c\C-xk" 'para-index-keystroke)
  324.   (define-key para-mode-map "\C-c\C-xp" 'para-index-program)
  325.   (define-key para-mode-map "\C-c\C-xt" 'para-index-datatype)
  326.   (define-key para-mode-map "\C-c\C-xv" 'para-index-variable)
  327.  
  328.   (define-key para-mode-map "\C-c\C-xx" 'para-insert-index))
  329.  
  330. ;;; For bindings inside the temporary buffer created by
  331. ;;; `para-list-visited-nodes', use:
  332. ;;;
  333. ;;; C-c C-p r         para-visited-xref       (based on `para-xref')
  334. ;;; C-c C-p C-m       para-goto-visited-node  (parallel to `para-menu')
  335. ;;;
  336. ;;;  (Note that the keybinding for `para-visited-xref' and
  337. ;;;  `para-goto-visited-node' are defined locally in the mode map for
  338. ;;;  the temporary buffer, not in the para-mode-map.)
  339.  
  340. ;;; For bindings inside the temporary buffer created by
  341. ;;; `para-directory', use:
  342. ;;;
  343. ;;; C-c C-p r       para-main-menu-buffer-xref (based on `para-xref')
  344. ;;; C-c C-p C-m     para-main-menu-goto-node   (parallel to `para-menu')
  345. ;;;
  346. ;;; (Keybinding defined in local keymap.)
  347.  
  348.  
  349. ;;; Mode line for Para mode
  350.  
  351. (defvar para-ignore-extension nil
  352.   "*If non-nil, visited filename extension not shown in mode-line.")
  353.  
  354. (defun para-set-mode-line ()
  355.   (let ((filename (file-name-nondirectory (buffer-file-name))))
  356.     (if para-ignore-extension
  357.         (setq filename
  358.               (substring filename 0         ; name sans extension
  359.                          (or (string-match "\\.tex" filename)
  360.                              (length filename)))))
  361.     (setq mode-line-modified '("--%1*%1*-")
  362.       mode-line-buffer-identification
  363.       (concat "Para mode: ("
  364.                   filename
  365.                   ")"
  366.                   (or para-current-node "")
  367.                   " "))))
  368.  
  369.  
  370. ;;; Para mode
  371.  
  372. (defun para-mode ()
  373.   "Hypertext-like extension of Texinfo.
  374. Provides editing and Info-like movement commands for Texinfo files.
  375.  
  376. When point is at the upper-left corner, or if the buffer is read-only,
  377. Emacs interprets key strokes as Info-like commands.  Otherwise,
  378. keystrokes self-insert.
  379.  
  380. The default keybindings are compatible with
  381. Texinfo mode.  The prefix keys for the different groups of commands
  382. are:
  383.  
  384.       TeX commands              prefix key: `C-c C-t'
  385.       Elisp formatting commands prefix key: `C-c C-e'
  386.       Makeinfo commands         prefix key: `C-c C-m'
  387.       Updating commands         prefix key: `C-c C-u'
  388.       String insertion commands prefix key: `C-c C-c'
  389.  
  390.       Para indexing commands    prefix key: `C-c C-x'
  391.       Para mode general         prefix key: `C-c C-p'
  392.  
  393. Primary movement commands are similar to those in Info:
  394. \\<para-mode-map>
  395.     Display the first menu:             \\[para-directory]
  396.     Go to the `Next' node:              \\[para-next]
  397.     Go to the `Previous' node:          \\[para-prev]
  398.     Go to the `Up' node:                \\[para-up]
  399.     Go to the menu item named:          \\[para-menu]
  400.  
  401. Primary editing features are:
  402.  
  403.     Create a file in Para mode 
  404.         and insert its header:          \\[para-make-file]
  405.     Create a new node
  406.         and section header:             \\[para-add-node]
  407.     Insert a Texinfo menu template:     \\[para-insert-menu]
  408.     Create new node and section 
  409.         headers at the end of the 
  410.         current node, based on menu:    \\[para-menu-explode]
  411.     Insert Texinfo cross reference:     \\[para-xref]
  412.     Make a master menu:                 \\[para-make-master-menu]
  413.  
  414. The commands are:
  415.  
  416. \\{para-mode-map}"
  417.   (interactive)
  418.   (text-mode)
  419.   (kill-all-local-variables)
  420.   (use-local-map para-mode-map)
  421.   (set-syntax-table para-mode-syntax-table)
  422.   (setq mode-name "Para"
  423.         major-mode 'para-mode)
  424.   (make-variable-buffer-local 'para-main-menu-completions-list)
  425.   (make-local-variable 'require-final-newline)
  426.   (make-local-variable 'paragraph-separate)
  427.   (make-local-variable 'paragraph-start)
  428.   (make-local-variable 'fill-column)
  429.   (make-local-variable 'comment-start)
  430.   (make-local-variable 'comment-start-skip)
  431.   (make-local-variable 'para-history)
  432.   (make-local-variable 'para-current-node)
  433.   (make-local-variable 'para-ignore-extension)
  434.   (make-local-variable 'para-last-search)
  435.   (setq require-final-newline t
  436.         paragraph-separate (concat "^\b\\|^@[a-zA-Z]*[ \n]\\|"
  437.                                    paragraph-separate)
  438.         paragraph-start (concat "^\b\\|^@[a-zA-Z]*[ \n]\\|" paragraph-start)
  439.         fill-column 72
  440.         comment-start "@c \|@comment "
  441.         comment-start-skip "@c +\|@comment +")
  442.   (para-narrow-to-node)
  443.   (run-hooks 'text-mode-hook 'texinfo-mode-hook 'para-mode-hook))
  444.  
  445.  
  446. ;;; Make a Para mode file; or quit.
  447.  
  448. ;;;     C-c C-p f       para-make-file       Create a file in Para mode 
  449. ;;;     C-c C-p C-q     para-quit            Change to Texinfo mode
  450.  
  451. (defun para-make-file (filename title node-name chapter-name)
  452.   "Create a file in Para mode and insert its header.
  453. Filename should end in `.tex', `.texi', or `.texinfo'. extension.
  454.  
  455. This command inserts the `setfilename' and `settitle' commands used by
  456. Texinfo.  Prompts user for FILENAME, TITLE used by TeX, first
  457. NODE-NAME, and first CHAPTER-NAME.
  458.  
  459. The Info file name is generated from the FILENMAE by removing the
  460. extension and replacing it with `.info'.  If the file already exists
  461. an error is signaled."
  462.   
  463.   (interactive
  464.    (list
  465.     (read-from-minibuffer "File name: ")
  466.     (read-from-minibuffer "Title: ")
  467.     (read-from-minibuffer "Name for first node: ")
  468.     (read-from-minibuffer "Name for first chapter: ")))
  469.   
  470.   (if (file-exists-p filename)
  471.       (error "File `%s' already exists!" filename))
  472.   
  473.   (find-file filename)
  474.   (set-syntax-table para-mode-syntax-table)
  475.   (goto-char (point-min))
  476.   
  477.   (let ((info-filename
  478.          (concat
  479.           (file-name-nondirectory
  480.            (substring 
  481.             filename 
  482.             0                         
  483.             (or (string-match "\\.tex" filename) (length filename))))
  484.           ".info")))
  485.     
  486.     ;; Format:
  487.     
  488.     ;; \input texinfo    @c -*-para-*-
  489.     ;; @setfilename INFO-FILENAME
  490.     ;; @settitle TITLE
  491.     ;; 
  492.     ;; @node top, 
  493.     ;; 
  494.     ;; @node NODE-NAME
  495.     ;; @chapter CHAPTER-NAME
  496.     ;; ...
  497.     ;; @bye
  498.  
  499.     (insert "\\input texinfo    @c -*-para-*-\n")
  500.     (insert (format "@setfilename %s\n" info-filename))
  501.     (insert (format "@settitle %s\n\n"  title))
  502.     (insert "@node top, \n\n")
  503.     (insert (format "@node %s,\n" node-name))
  504.     (insert (format "@chapter %s\n\n\n\n" chapter-name))
  505.     (insert "@bye\n")
  506.     (para-mode)
  507.     (forward-line -3)
  508.     (widen)))
  509.  
  510. (defun para-quit ()
  511.   "Exit para mode"
  512.   (interactive)
  513.   (widen)
  514.   (texinfo-mode))
  515.  
  516.  
  517. ;;; Add a new node
  518. ;;;    C-c C-p a       para-add-node
  519.  
  520. (defun para-add-node (new-node-type name title)
  521.   "Create new node and section headers.
  522.  
  523. In interactive use, 
  524.  
  525.     1. No prefix argument: section type defaults to the same type as
  526.        the preceding node.
  527.  
  528.     2. With prefix arg, obtain a prompt for the section type.  A
  529.        default is offered, which one level lower than the preceding
  530.        node (unless the previous node is already at the lowest level).
  531.  
  532.     You are prompted for the node name and section title.
  533.  
  534. If the new node is 
  535.  
  536.     * at the same or lower hierarchical level than the preceding node,
  537.       the function inserts new headers at point;
  538.  
  539.     * at a higher hierarchical level than the preceding node,
  540.       the function inserts new headers just before next node of 
  541.       the new level, or at the end of the buffer.
  542.  
  543. The function updates the appropriate node lines and the associated
  544. menu, but not the main menu (unless the new node is a chapter).
  545.  
  546. In non-interactive use, the first argument is the TYPE or level of the
  547. new node; the second argument is the the node NAME and the and third
  548. argument is the section TITLE."
  549.   (interactive
  550.      (if (not current-prefix-arg) 
  551.          (let ((preceding-node-type (para-preceding-node-type)))
  552.            ;; top node case
  553.            (if (string= preceding-node-type "top")
  554.                (setq preceding-node-type "chapter"))
  555.            (list preceding-node-type
  556.                  (read-string
  557.                   (format "Node name for `%s' (end with RET): "
  558.                               (para-preceding-node-type)))
  559.                  (read-string "Title (end with RET): ")))
  560.        ;; Ask what new node level should be; this becomes the 
  561.        ;; value of new-node-type even though it starts out as
  562.        ;; the prefix arg
  563.        (list
  564.         (read-no-blanks-input
  565.          "New node level: "
  566.          (cdr (assoc (para-preceding-node-type) para-subtype-alist)))
  567.         (read-string "Node name (end with RET): ")
  568.         (read-string "Title (end with RET): "))))
  569.  
  570.   (let* ((preceding-node-type (para-preceding-node-type))
  571.          (new-node-general-type
  572.           (cdr (assoc preceding-node-type texinfo-section-to-generic-alist))))
  573.     ;; top node case
  574.     (if (string= preceding-node-type "top")
  575.         (setq preceding-node-type "chapter"
  576.               new-node-general-type "chapter"))
  577.  
  578.     ;; Adding new nodes has three cases:
  579.     ;;
  580.     ;;     1. New node is at same level as preceding node:
  581.     ;;        insert it at point.
  582.     ;;
  583.     ;;     2. New node is at lower level than preceding node:
  584.     ;;        also, insert it at point.
  585.     ;;
  586.     ;;     3. New node is at higher level than preceding node:
  587.     ;;        insert it at end of the preceding node of the same level
  588.     ;;        after any intervening nodes; i.e. put it just before the
  589.     ;;        next node of that level.
  590.  
  591.     (if (not new-node-type)
  592.         ;; 1. most common case; insert same level node at point
  593.         (insert
  594.          (format "\n@node %s,\n@%s %s\n" name preceding-node-type title))
  595.  
  596.       ;; Else insert a node at a different level:
  597.  
  598.       (setq new-node-general-type      
  599.             (cdr
  600.              (assoc
  601.               new-node-type texinfo-section-to-generic-alist)))
  602.  
  603.       ;; 2. If the node is at a same or lower level, insert at point;
  604.       ;; but if the node is at a higher level, insert it just before
  605.       ;; next node of that level.
  606.  
  607.       (if (node-same-or-lower-level-p new-node-type preceding-node-type)
  608.           (insert (format "\n@node %s,\n@%s %s\n" name new-node-type title))
  609.  
  610.         ;; 3. Else the new node level is higher then the preceding node.
  611.         ;; Find next node of that level:
  612.         (if (re-search-forward
  613.              (concat
  614.               "\\(^@node\\).*\n"        ; match node line
  615.               "\\(\\(^@c\\|^@if\\).*\n\\)?"    ; match comment or
  616.                                                ; ifinfo line, if any
  617.               (eval
  618.                (cdr                     ; return regexp for search
  619.                 (assoc
  620.                   new-node-general-type
  621.                  texinfo-update-menu-same-level-regexps))))
  622.              nil
  623.              'goto-end)
  624.             (goto-char (match-beginning 0))
  625.           (point-max))
  626.         (insert
  627.          (format "\n@node %s,\n@%s %s\n\n" name new-node-type title))
  628.         (forward-line -1)))
  629.  
  630.     ;; Finally, update relevant pointers and menu
  631.     (para-insert-update-pointers-&-menu new-node-general-type)
  632.     (message "Added new node: name, `%s'; title, `%s' ... Done."
  633.              name title)))
  634.  
  635.  
  636. ;;; Utility functions for `para-add-node'
  637.  
  638. (defun para-preceding-node-type ()
  639.   "Return type of preceding node as string, eg \"section\" or \"chapter\"."
  640.     (save-excursion
  641.       (end-of-line)
  642.       (if (re-search-backward "^@node" nil t)
  643.           (if (looking-at "^@node [ \t]*top")
  644.               ;; top node case: return top
  645.               "top"
  646.             ;;else
  647.             (if (re-search-forward
  648.                  (concat
  649.                   "\\(^@node\\).*\n"            ; match node line
  650.               "\\(\\(^@c\\|^@if\\).*\n\\)?"     ; match comment or
  651.                                                 ; ifinfo line, if any
  652.                   "\\(^@\\).*")                 ; match title line 
  653.                  nil 
  654.                  t)
  655.                 (buffer-substring
  656.                  (progn (beginning-of-line) ; copy its name
  657.                         (1+ (point)))
  658.                  (progn (forward-word 1)
  659.                         (point)))))
  660.         ;; else no node line found
  661.         (error "No preceding node!"))))
  662.  
  663. (defun node-same-or-lower-level-p (new-node-type preceding-node-type)
  664.   "t if NEW-NODE-TYPE at same or lower level as PRECEDING-NODE-TYPE."
  665.   (let ((new-node-general-type
  666.          (cdr (assoc new-node-type texinfo-section-to-generic-alist)))
  667.         (node-sequence
  668.          (assoc        ; returns list of same and lower types
  669.           (cdr (assoc         
  670.                 preceding-node-type
  671.                 texinfo-section-to-generic-alist))
  672.           para-matching-subtypes-alist)))
  673.     (node-in-sequence-p new-node-general-type node-sequence)))
  674.  
  675. (defun node-in-sequence-p (node node-sequence)
  676.   "Return t if NODE is at same or lower level in NODE-SEQUENCE.
  677. The node sequence is a list of strings of the general type of node,
  678. such as `subsection' or `unnumbered'."
  679.   (if node-sequence
  680.       (if (string= node
  681.                    (car node-sequence))
  682.           t
  683.         (node-in-sequence-p node (cdr node-sequence)))))
  684.  
  685.  
  686. ;;; `para-add-node' utility; goto node of specified general type
  687.  
  688. (defun para-goto-node-of-type (type direction)
  689.   "Move point to node of specified general TYPE in specified DIRECTION.
  690. Return nil if specified node not found, otherwise, move point."
  691.   (widen)
  692.   (let ((search-function
  693.          (cond ((eq direction 'next) 're-search-forward)
  694.                ((eq direction 'previous) 're-search-backward))))
  695.     (if (string= "chapter" type)
  696.         (if
  697.             (funcall search-function
  698.                      (concat
  699.                       "\\("
  700.                       "\\(^@node [ \t]*top\\)"    ; top node case
  701.                       "\\|"                       ; or
  702.                       "\\(^@node\\).*\n"          ; match node line
  703.                       "\\(\\(^@c\\|^@if\\).*\n\\)?"      ; match comment
  704.                                                   ; or ifinfo line, if any
  705.                       "\\(^@"                     ;match chapter line
  706.                       texinfo-chapter-level-regexp 
  707.                       "\\)"                 
  708.                       "\\)")
  709.                      nil
  710.                      t)
  711.             (goto-char (match-beginning 0))
  712.           ;; else node not found
  713.           nil)
  714.       ;;else not a chapter
  715.       (if (funcall search-function
  716.                    (concat
  717.                     "\\(^@node\\).*\n"     ; match node line
  718.                     "\\(\\(^@c\\|^@if\\).*\n\\)?" ; match comment 
  719.                                            ; or ifinfo line, if any
  720.                     (eval
  721.                      (cdr
  722.                       (assoc type texinfo-update-menu-same-level-regexps))))
  723.                    nil
  724.                    t)
  725.           (goto-char (match-beginning 0))
  726.         ;; else node not found
  727.         nil))))
  728.  
  729.  
  730. ;;; `para-add-node' utility; insert and update pointers and menu 
  731.  
  732. (defun para-insert-update-pointers-&-menu (new-node-general-type)
  733.   "Insert pointers of an added node, update other pointers and menu.
  734. Specifically, insert the Next, Previous, and Up pointers of the current
  735. node, update the pointers of the Next and Previous nodes, and update
  736. the menu for the added node."
  737.   (let ((auto-fill-hook nil))
  738.     (save-excursion
  739.     ;; First, update current node:
  740.     (if (not (re-search-backward "^@node" (point-min) t))
  741.         (error "Node line not found before this position."))
  742.     (texinfo-update-the-node)
  743.     ;; Second, update previous node:
  744.     (save-excursion
  745.       (if (para-goto-node-of-type new-node-general-type 'previous)
  746.           (texinfo-update-the-node)))
  747.     ;; Third, update next node:
  748.     (save-excursion
  749.       (if (para-goto-node-of-type new-node-general-type 'next)
  750.           (texinfo-update-the-node)))
  751.     ;; Finally, update the menu for this node
  752.     (save-excursion
  753.       (texinfo-make-one-menu new-node-general-type)))))
  754.  
  755.  
  756. ;;; Add new nodes based on menu:  `para-menu-explode'
  757.  
  758. (defun para-menu-explode ()
  759.   "Based on menu, create new node and section headers at end of current node.
  760. Each node name is extracted from a menu entry, and the corresponding
  761. section title is the same as the descriptive string in that menu
  762. entry."
  763.   (interactive)
  764.   (if (re-search-backward "^@node" (point-min) t)
  765.       (let* ((up-node (texinfo-copy-node-name))
  766.              (new-node-type
  767.               (cdr (assoc (para-preceding-node-type) para-subtype-alist)))
  768.              (new-node-general-type
  769.               (cdr (assoc new-node-type
  770.                           texinfo-section-to-generic-alist)))
  771.  
  772.              menu-end menu next-node previous-node)
  773.         
  774.         (if (string= new-node-general-type "subsubsection")
  775.             (error "This node is too deep to create subnodes."))
  776.         
  777.         (if (search-forward "\n@menu" nil t)
  778.             (save-excursion
  779.               (if (search-forward "\n@end menu" nil t)
  780.                   (setq menu-end (point))
  781.                 (error "No \"@end menu\" found!")))
  782.           (error "No menu found!"))
  783.         ;; create list of node names and titles
  784.         (while (not (looking-at "^@end menu"))
  785.           (setq menu
  786.                 (cons
  787.                  (cons
  788.                   (para-extract-menu-node-name)
  789.                   (para-main-menu-buffer-copy-description menu-end))
  790.                  menu))
  791.           (forward-line 1))
  792.         
  793.         (setq menu (reverse menu)
  794.               next-node (append (cdr menu) (list (cons "" "")))
  795.               previous-node (append (list (cons "" "")) menu))
  796.         
  797.         (if (re-search-forward "^@node\\|^@bye" (point-max) 'move)
  798.             (forward-line -1))
  799.         
  800.         (while menu
  801.           
  802.           (insert
  803.            (format
  804.             "\n@node %s, %s, %s, %s\n@%s %s\n"
  805.             (car (car menu)) (car (car next-node))
  806.             (car (car previous-node)) up-node
  807.             new-node-type (cdr (car menu))))
  808.           
  809.           (setq menu (cdr menu) 
  810.                 next-node (cdr next-node)
  811.                 previous-node (cdr previous-node)))
  812.         
  813.         (recenter -1))
  814.     (error "Node line not found before this position.")))
  815.  
  816.  
  817. ;;; Insert a Texinfo cross reference
  818. ;;; C-c C-p r       para-xref
  819.  
  820. (defun para-xref (insert-topic-p nodename description)
  821.   "Insert a Texinfo cross reference.
  822.  
  823. The first argument, if non-nil, means incorporate topic description in
  824. reference.  In interactive use, this argument is optional prefix
  825. argument.  The second argument is the NODENAME for the reference, the
  826. third argument is the topic DESCRIPTION.  
  827.  
  828. If `para-main-menu-completions-list' is non-nil, completion for node
  829. names in the list. \(No default offered---you have to type the
  830. beginning of the node name.  Type \\[para-directory] to generate a
  831. `para-main-menu-completions-list' if it does not exist.\)"
  832.   
  833.   (interactive
  834.    (let* ((completion-ignore-case t)
  835.           (insert-topic-p  current-prefix-arg)
  836.           (node-name
  837.            (if (get-buffer para-main-menu-buffer-name)
  838.                (save-excursion
  839.                  (set-buffer para-main-menu-buffer-name)
  840.                  (completing-read
  841.                   "Node name (with completion): "
  842.                   para-main-menu-completions-list))
  843.              (read-string "Node name: ")))
  844.  
  845.           (description
  846.            (if insert-topic-p  
  847.                (read-string "Topic description (end with RET): "
  848.                         (if (get-buffer para-main-menu-buffer-name)
  849.                             (save-excursion
  850.                               (set-buffer para-main-menu-buffer-name)
  851.                               (goto-char (point-min))
  852.                               (if (re-search-forward
  853.                                    (regexp-quote node-name)
  854.                                    nil t)
  855.                                   (progn
  856.                                     (beginning-of-line)
  857.                                     (search-forward ":")
  858.                                     (para-main-menu-buffer-copy-description
  859.                                      (point-max)))
  860.                                 ""))
  861.                           ""))
  862.              "")))
  863.      (list  insert-topic-p node-name description)))
  864.   (if (string= "" description)
  865.       (insert (format "@xref{%s}." nodename))
  866.     (insert (format "@xref{%s, , %s}." nodename  description))))
  867.  
  868.  
  869. ;;; Chapter, section, etc. types alists
  870. (defvar para-matching-subtypes-alist
  871.   '(("top" . ("chapter" "section" "subsection" "subsubsection"))
  872.  
  873.     ("chapter" . ("section" "subsection" "subsubsection"))
  874.     
  875.     ("section" . ("subsection" "subsubsection"))
  876.     
  877.     ("subsection" . ("subsubsection"))
  878.     
  879.     ("subsubsection" . nil))
  880.   "*Alist matchining each general section type with a list of its same
  881.   and sub types.")
  882.  
  883. (defvar para-subtype-alist
  884.   '(("top" . "chapter")
  885.  
  886.     ("chapter" . "section")
  887.     ("unnumbered" . "unnumberedsec")
  888.     ("majorheading" . "heading")
  889.     ("chapheading" . "heading")
  890.     ("appendix" . "appendixsec")
  891.     
  892.     ("section" . "subsection")
  893.     ("unnumberedsec" . "unnumberedsubsec")
  894.     ("heading" . "subheading")
  895.     ("appendixsec" . "appendixsubsec")
  896.     
  897.     ("subsection" . "subsubsection")
  898.     ("unnumberedsubsec" . "unnumberedsubsubsec")
  899.     ("subheading" . "subsubheading")
  900.     ("appendixsubsec" . "appendixsubsubsec")
  901.     
  902.     ("subsubsection" . "subsubsection")
  903.     ("unnumberedsubsubsec" . "unnumberedsubsubsec")
  904.     ("subsubheading" . "subsubheading")
  905.     ("appendixsubsubsec" . "appendixsubsubsec"))
  906.   "*Alist of section types and their subtypes.")
  907.  
  908.  
  909. ;;; Narrow to node
  910.  
  911. ;;;    C-c C-p n       para-narrow-to-node
  912.  
  913. (defun para-narrow-to-node ()
  914.   "Narrow to current node."
  915.   (interactive)
  916.   (let ((current-position (point))
  917.         end-of-node-name
  918.         beginning-of-node)
  919.     (widen)
  920.     (beginning-of-line)
  921.     (if (or (looking-at "^@node")
  922.             (re-search-backward "^@node"  nil 'move-to-limit))
  923.         ;; point is within a node
  924.         (progn
  925.           (re-search-forward "@node[ \t]*\\<\\([^,]*\\),")
  926.           (setq end-of-node-name
  927.                 (point)
  928.                 para-current-node
  929.                 (buffer-substring (match-beginning 1) (match-end 1)))
  930.           (beginning-of-line)
  931.           (while (looking-at "^@")
  932.             (forward-line -1))
  933.           (forward-line 1)
  934.           (setq beginning-of-node (point))
  935.           ;; skip past beginning node name
  936.           (goto-char end-of-node-name))
  937.       ;; else point is before first node
  938.       (setq beginning-of-node 1
  939.             para-current-node  "Beginning of Buffer"))
  940.     (para-set-mode-line)
  941.     ;; search for next node
  942.     (if (search-forward "\n@node" nil 'move-to-limit)
  943.         (progn
  944.           (beginning-of-line)
  945.           (while (looking-at "^@")
  946.             (forward-line -1))))
  947.     (narrow-to-region beginning-of-node (point))
  948.     (goto-char current-position)))
  949.  
  950.  
  951. ;;; Goto a node.
  952.  
  953. (defun para-goto-node (name)
  954.   "Go to NAME, which may be `nodename' or `(filename)nodename'.
  955. This is an interface to the function `para-goto'."
  956.   (interactive "sGoto: ")
  957.   (if (not (para-goto name)
  958.            (error "Node not found: %s " name))))
  959.  
  960. (defun para-goto (name)
  961.   "Go to NAME, which may be `nodename' or `(filename)nodename'.
  962. Use `para-goto-node' interactively."
  963.   
  964.   ;; If the string passed as `name' starts with a left parenthesis,
  965.   ;; then the text within parentheses is the name of a file
  966.   
  967.   (let (filename nodename)
  968.     (if (string-equal (substring name 0 1) (char-to-string ?\())
  969.         ;; then name starts with filename
  970.         (setq filename
  971.               (substring name 1 (string-match (char-to-string ?\)) name))
  972.               nodename
  973.               (substring name (1+ (string-match (char-to-string ?\))  name))))
  974.       ;; else name is nodename only
  975.       (setq filename nil
  976.             nodename name))
  977.     
  978.     (cond 
  979.            ;; if file name is `dir', go to Info directory
  980.            ((and filename
  981.                 (string= (downcase filename) "dir")) (Info-directory))
  982.  
  983.            (filename                       ; i.e., if there is a filename
  984.             (if (string-equal nodename "") ; go to file, which will
  985.                                            ; enter para mode if it is
  986.                                            ; that type
  987.                 (switch-to-buffer (find-file-noselect filename))
  988.               ;; else go to a  node in the file \(must be a Para mode file\)
  989.               (find-file filename)
  990.               (widen) 
  991.               (goto-char (point-min))
  992.               (para-goto nodename)))
  993.            
  994.            ((string-equal nodename "*")
  995.             (para-beginning)
  996.             (setq para-current-node nodename)
  997.             (setq para-history (cons para-current-node para-history))
  998.             (para-set-mode-line))
  999.           
  1000.            ;; else must be a node to go to
  1001.            (t
  1002.             (let ((current-position (point)))
  1003.               (widen)
  1004.               (goto-char (point-max))
  1005.               ;; if both a tag table and find node, goto it
  1006.               (if (and
  1007.                    (search-backward "End tag table\n@end ignore" nil t)
  1008.                    (para-tag-table-find))
  1009.                   ;; then
  1010.                   (progn
  1011.                     (para-narrow-to-node)
  1012.                     ;; para-narrow-to-node specifies value of para-current-node
  1013.                     (setq para-history (cons para-current-node para-history))
  1014.                     (para-set-mode-line)
  1015.                     t)
  1016.                 ;; else either no tag table or node not in tag table
  1017.                 (if (re-search-backward
  1018.                      (concat "^@node [ \t]*" nodename) nil t)
  1019.                     ;; then
  1020.                     (progn
  1021.                       (para-narrow-to-node)
  1022.                       (setq para-history (cons para-current-node para-history))
  1023.                       (para-set-mode-line)
  1024.                       t)
  1025.                   ;; else could not find new node, return to current position
  1026.                   (goto-char current-position)
  1027.                   (para-narrow-to-node)
  1028.                   nil)))))))
  1029.  
  1030. (defun para-tag-table-find ()
  1031.   "Use a tag table to assist in going to a node quickly.
  1032. Tag table must be at the end of a Para mode file in an @ignore.
  1033. Point must be closer to the end than the beginning of the @ignore."
  1034.   (and (search-backward "@ignore\nTag table:" nil t)
  1035.        (search-forward (concat "Node: " nodename "\177") (point-max) t)
  1036.        (para-tag-search nodename (read (current-buffer)) 500)))
  1037.  
  1038. (defun para-tag-search (node point chunk)
  1039.   "Search for NODENAME from POINT, forward and back in CHUNK-sized spans."
  1040.   (let ((forward-search-position point)
  1041.     (backward-search-position point)
  1042.     (target-node (concat "^@node[ \t]+" (regexp-quote node) "[ \t]*,"))
  1043.         (max-limit (point-max))
  1044.     forward-limit backward-limit found)
  1045.     
  1046.     (while (not found)
  1047.       (setq forward-limit
  1048.             (min max-limit (+ forward-search-position chunk))
  1049.         backward-limit
  1050.             (max 1 (- backward-search-position chunk)))
  1051.       (goto-char forward-search-position)
  1052.       
  1053.       (if (and (< forward-search-position max-limit)
  1054.                (re-search-forward target-node forward-limit t))
  1055.           (progn
  1056.             (beginning-of-line)
  1057.             (setq found (point))) ; and exit while loop
  1058.         
  1059.     ;;else
  1060.         (goto-char backward-search-position)
  1061.     (if (and (< 1 backward-search-position)
  1062.                  (re-search-backward target-node backward-limit t))
  1063.             (setq found (point)) ; and exit while loop
  1064.           
  1065.           ;; else
  1066.       (if (and (= forward-search-position max-limit)
  1067.                    (= backward-search-position (point-min)))
  1068.           (setq found 'at-limits) ; and exit while loop
  1069.             ;; else repeat while loop 
  1070.         (setq forward-search-position forward-limit
  1071.                   backward-search-position backward-limit)))))
  1072.     
  1073.     (if (numberp found)
  1074.     (goto-char found)
  1075.       nil)))
  1076.  
  1077.  
  1078. ;;; Tagify a Para mode file
  1079.  
  1080. (defun para-tagify ()
  1081.   "Create or update a Para mode tag table in the current buffer."
  1082.   (interactive)
  1083.   ;; Save and restore point and restrictions.
  1084.   ;; `save-restriction' would not work
  1085.   ;; because it records the old max relative to the end.
  1086.   ;; Record it relative to the beginning.
  1087.   (let ((old-minimum (point-min))
  1088.     (old-maximum (point-max))
  1089.     (no-max (= (point-max) (1+ (buffer-size))))
  1090.     (old-point (point)))
  1091.     (unwind-protect
  1092.     (progn
  1093.       (widen)
  1094.       (goto-char 1)
  1095.       (let ((case-fold-search t)
  1096.         list)
  1097.         (while (search-forward "\n@node" nil t)
  1098.           (forward-line -1)
  1099.           (let ((beg (point)))
  1100.         (forward-line 2)
  1101.         (if (re-search-backward "^@node[ \t]+\\([^,]+\\)," beg t)
  1102.                     (setq list
  1103.               (cons (list (para-clean-name
  1104.                        (buffer-substring
  1105.                     (match-beginning 1)
  1106.                     (match-end 1))
  1107.                        " \t")
  1108.                       beg)
  1109.                 list)))))
  1110.         (goto-char (point-max))
  1111.         (let ((buffer-read-only nil))
  1112.           (if (not (search-backward "\n@bye" nil t))
  1113.                   (error "This file requires an `@bye'!")
  1114.                 ;; else removing existing tag table if there is one
  1115.                 (if (search-forward "\nEnd tag table\n@end ignore\n" nil t)
  1116.           (let ((end (point)))
  1117.             (search-backward "\nTag table:\n")
  1118.             (beginning-of-line)
  1119.             (delete-region (point) end))))
  1120.           (goto-char (point-max))
  1121.           (insert "\n \n@ignore\nTag table:\n")
  1122.           (setq list (nreverse list))
  1123.           (while list
  1124.         (insert "Node: " (car (car list)) ?\177)
  1125.         (princ (car (cdr (car list))) (current-buffer))
  1126.         (insert ?\n)
  1127.         (setq list (cdr list)))
  1128.         (insert "\nEnd tag table\n@end ignore\n")))))
  1129.       (goto-char old-point)
  1130.       (narrow-to-region old-minimum (if no-max (1+ (buffer-size))
  1131.                  (min old-maximum (point-max))))))
  1132.  
  1133. (defun para-clean-name (string chars-to-remove)
  1134.   "Remove leading/trailing characters from STRING that match CHARS-TO-REMOVE."
  1135.   (if (string= chars-to-remove "") string
  1136.     ;; else
  1137.     (let* ((i 0)
  1138.        (regex-to-remove (concat "[" chars-to-remove "]"))
  1139.        (dont-remove (concat "[^" chars-to-remove "]"))
  1140.            ;; delete leading chars-to-remove
  1141.        (string (substring string (or (string-match dont-remove string) 0)))
  1142.        (l (length string)))
  1143.       (while (and (< i l) (string-match regex-to-remove (substring string -1)))
  1144.     (setq i (1+ i) string (substring string 0 -1)))
  1145.       string)))
  1146.  
  1147.  
  1148. ;;; Insert a menu.
  1149. ;;;    C-c C-p i       para-insert-menu
  1150.  
  1151. (defun para-insert-menu () 
  1152.   "Insert a Texinfo menu template and position point within it."
  1153.   (interactive)
  1154.   (insert "@menu\n* ::\t\t\n@end menu\n")
  1155.   (forward-line -2)
  1156.   (forward-char 2))
  1157.  
  1158.  
  1159. ;;; Make a Master Menu
  1160.  
  1161. ;;; C-c C-p m       para-make-master-menu
  1162.  
  1163. ;;; `para-master-menu' is a rewrite of texinfo-master-menu and,
  1164. ;;; perhaps, should replace that function.  What is new is that
  1165. ;;; para-master-menu removes a pre-existing detailed part of the
  1166. ;;; master menu---but if the pre-existing master menu uses a
  1167. ;;; non-standard `texinfo-master-menu-header', this removal fails.
  1168. ;;; Also, para-master-menu removes extra blank lines that the menu
  1169. ;;; insert functions insert (and should insert, lest there be no blank
  1170. ;;; line separates when you make the first master menu).
  1171.  
  1172. ;;; Replace following with texinfo-master-menu?  Yes, but also provide
  1173. ;;; an indented master menu option.
  1174.  
  1175. ;;; Currently, `texinfo-master-menu' works like this:
  1176. ;;;  "Make a master menu for a whole Texinfo file.
  1177. ;;;Non-nil argument (prefix, if interactive) means first update all
  1178. ;;;existing nodes and menus.  Remove pre-existing master menu, if there is one.
  1179.  
  1180. (defun para-make-master-menu
  1181.   (&optional update-all-nodes-menus-p para-indented-master-menu-p)
  1182.   "Make a master menu for a whole Para mode file.
  1183.  
  1184. In interactive use:
  1185.  
  1186.     1. With no prefix arg, make a regular master menu, first removing
  1187.        detailed part of pre-existing master menu, if there is one.
  1188.  
  1189.     2. With prefix arg, first update all existing nodes and menus
  1190.        \(incorporating descriptions from pre-existing menus\), first
  1191.        removing detailed part of pre-existing master menu, if there is
  1192.        one.
  1193.  
  1194.     3. With numeric prefix arg, insert an indented master menu.  All
  1195.        the nodes are in sequence.
  1196.  
  1197.     4. With negative numeric prefix arg, first update all existing
  1198.        nodes and menus \(incorporating descriptions from pre-existing
  1199.        menus\).  First remove detailed part of pre-existing master
  1200.        menu, if there is one, then insert an indented master menu.
  1201.  
  1202. When called from a program, non-nil optional first arg means first
  1203. update all existing nodes and menus \(incorporating descriptions from
  1204. pre-existing menus\); non-nil optional second arg means insert an
  1205. indented master menu in which all the nodes are in sequence.
  1206.  
  1207. This function creates a menu that follows the top node.  It replaces
  1208. any existing menu there, first removing the detailed part of an
  1209. already existing master.  \(This action depends on the pre-exisitng
  1210. master menu using the standard `texinfo-master-menu-header'.\)
  1211.  
  1212. A regular master menu has the following format, which is adapted from the
  1213. recommendation in the Texinfo Manual:
  1214.  
  1215.    * The first part contains the major nodes in the Texinfo file: the
  1216.      nodes for the chapters, chapter-like sections, and the major
  1217.      appendices.  This includes the indices, so long as they are in
  1218.      chapter-like sections, such as unnumbered sections.
  1219.  
  1220.    * The second and subsequent parts contain a listing of the other,
  1221.      lower level menus, in order.  This way, an inquirer can go
  1222.      directly to a particular node if he or she is searching for
  1223.      specific information.
  1224.  
  1225. Each of the menus in the detailed node listing is introduced by the
  1226. title of the section containing the menu.
  1227.  
  1228. An indented master menu consists of all the menu entries in the
  1229. buffer, in sequence, with lower level menus indented according to
  1230. their hierarchical level."
  1231.   (interactive
  1232.    (cond ((not current-prefix-arg) (list nil nil))
  1233.          ((listp current-prefix-arg) (list t nil))
  1234.          ((> (prefix-numeric-value current-prefix-arg) 0) (list nil t))
  1235.          ((< (prefix-numeric-value current-prefix-arg) 0) (list t t))))
  1236.   (widen)
  1237.   (goto-char (point-min))
  1238.   
  1239.   ;; Move point to location after `top'.
  1240.   (if (not (re-search-forward "^@node [ \t]*top[ \t]*\\(,\\|$\\)" nil t))
  1241.       (error "This buffer needs a Top node!"))
  1242.   
  1243.   (let ((first-chapter                  
  1244.          (save-excursion (re-search-forward "^@node") (point))))
  1245.     (if (re-search-forward texinfo-master-menu-header first-chapter t)
  1246.         ;; Remove detailed master menu listing
  1247.         (progn
  1248.           (goto-char (match-beginning 0))
  1249.           (let ((end-of-detailed-menu-descriptions
  1250.                  (save-excursion     ; beginning of end menu line
  1251.                    (goto-char (texinfo-menu-end))
  1252.                    (beginning-of-line) (forward-char -1)
  1253.                    (point))))
  1254.             (delete-region (point) end-of-detailed-menu-descriptions)))))
  1255.   
  1256.   (if update-all-nodes-menus-p
  1257.       (progn
  1258.         (message "Making a master menu...first updating all nodes... ")
  1259.         (sleep-for 2)
  1260.         (mark-whole-buffer)
  1261.         (texinfo-update-node t)
  1262.         
  1263.         (message "Updating all menus... ")        
  1264.         (sleep-for 2)
  1265.         (mark-whole-buffer)
  1266.         (texinfo-make-menu t)))
  1267.   
  1268.   (message "Now making the master menu... ")
  1269.   (sleep-for 2)
  1270.   (goto-char (point-min))
  1271.   
  1272.   (if para-indented-master-menu-p
  1273.       (progn
  1274.         (para-insert-indented-master-menu)
  1275.         (message
  1276.          "Done...completed making indented master menu.  You may save the buffer."))
  1277.     ;; else
  1278.     (texinfo-insert-master-menu-list
  1279.      (texinfo-master-menu-list))
  1280.     
  1281.     ;; Remove extra newlines that texinfo-insert-master-menu-list
  1282.     ;; may have inserted.
  1283.     
  1284.     (save-excursion
  1285.       (goto-char (point-min))
  1286.       
  1287.       (re-search-forward texinfo-master-menu-header)
  1288.       (goto-char (match-beginning 0))
  1289.       (insert "\n")
  1290.       (delete-blank-lines)
  1291.       
  1292.       (re-search-backward "^@menu")
  1293.       (forward-line -1)
  1294.       (delete-blank-lines)
  1295.       
  1296.       (re-search-forward "^@end menu")
  1297.       (forward-line 1)
  1298.       (delete-blank-lines)
  1299.       
  1300.       (message 
  1301.        "Done...completed making master menu.  You may save the buffer."))))
  1302.  
  1303.  
  1304. ;;; Find node in current buffer or other file with `para-menu'.
  1305. ;;; C-c C-p C-m     para-menu
  1306.  
  1307. ; The format must be one of following:
  1308.  
  1309.     ; * nodename::                   description
  1310.     ; * item:nodename.               description
  1311.     ; * item:(filename).             description
  1312.     ; * item:(filename)nodename.     description
  1313.  
  1314. ; (The `description' is optional.)
  1315. ; 
  1316. ; The file name must either be to a file in the current directory or a
  1317. ; full, absolute pathname.
  1318. ; 
  1319. ; To go to the item, position the cursor at the beginning of the line
  1320. ; for the item and type `C-c C-p C-m' and then type a RET to confirm
  1321. ; the default item.
  1322.  
  1323. (defun para-menu (menu-item)
  1324.   "Go to node for menu item named (or abbreviated) NAME.
  1325. In interactive use, default is node under cursor. 
  1326. Completion for any name in this menu."
  1327.   (interactive
  1328.    (list
  1329.     (let (completions
  1330.       (p (point))
  1331.           (default
  1332.             (save-excursion
  1333.               (beginning-of-line)
  1334.               (if (re-search-forward "\\* \\([^:\t\n]*\\):" nil t)
  1335.                   (buffer-substring (match-beginning 1) (match-end 1))
  1336.                 (prog1 nil (message "No default menu item found."))))))
  1337.       (save-excursion
  1338.     (goto-char (point-min))
  1339.     (if (not (search-forward "\n@menu" nil t))
  1340.         (error "No menu in this node.")
  1341.           ;; create alist for completing-read
  1342.           (while (re-search-forward
  1343.                   "\\* \\([^:\t\n]*\\):" nil t)
  1344.             ;; make a list,
  1345.             ;; each of element of which is \("name" . position\)
  1346.             (setq completions (cons (cons (buffer-substring
  1347.                                            (match-beginning 1)
  1348.                                            (match-end 1))
  1349.                                           (match-beginning 1))
  1350.                                     completions)))
  1351.           (let (item)
  1352.             (setq item (let ((completion-ignore-case t))
  1353.                          (completing-read
  1354.                           (if default
  1355.                               (format "Menu item (default %s): " default)
  1356.                             "Menu item: ")
  1357.                           completions nil t)))
  1358.             (if (string= item "") default item)))))))
  1359.   (save-excursion
  1360.     (goto-char (point-min))
  1361.     (or (search-forward "\n@menu" nil t)
  1362.     (error "No menu in this node"))
  1363.     (para-goto (para-extract-menu-name menu-item))))
  1364.  
  1365. (defun para-extract-menu-name (menu-item)
  1366.   "Return `nodename' or `(filename)nodename' for MENU-ITEM.
  1367. Point must be on or before named menu-item."
  1368.   (beginning-of-line)
  1369.   (or (re-search-forward (concat "* " "\\(" menu-item "\\)") nil t)
  1370.       (error "No such item in menu"))
  1371.   (para-extract-menu-node-name))
  1372.  
  1373. (defun para-extract-menu-node-name ()
  1374.   "Return `nodename' or `(filename)nodename'
  1375. Point must be on or before menu line."
  1376.  
  1377. ;;; Four circumstances:
  1378.  
  1379. ;;; * nodename::                   description
  1380. ;;; * item:nodename.               description
  1381. ;;; * item:(filename).             description
  1382. ;;; * item:(filename)nodename.     description
  1383.  
  1384. ;;; If a nodename is the second part of a menu item, you may follow it
  1385. ;;; with a period, comma, tab, or newline.
  1386.  
  1387.   (beginning-of-line)
  1388.   (or (re-search-forward (concat "* \\(\\w+\\)") nil t)
  1389.       (error "Cannot find a menu line."))
  1390.   (let ((start-of-name (match-beginning 1))
  1391.         node)
  1392.     (if (and
  1393.          (search-forward ":" nil t)
  1394.          (looking-at ":"))                            ; look at `::'
  1395.         (setq node
  1396.               (buffer-substring start-of-name (1- (point)))) ; return nodename
  1397.       ;;else
  1398.       (skip-chars-forward ": \t")
  1399.       (setq start-of-name (point))
  1400.       (if (search-forward "(" nil t)    ; skip over node name, if any
  1401.           (progn (goto-char (1- (point)))
  1402.                  (forward-sexp)))
  1403.       (re-search-forward "[.,\t\n]" nil t)
  1404.       ;; return either `nodename',`(filename)', or `(filename)nodename'
  1405.       (setq node (buffer-substring start-of-name (1- (point)))))
  1406.     node))
  1407.  
  1408.  
  1409. ;;; Goto the first, second, third node in a menu.
  1410. ;;;    C-c C-p 1       para-menu-1      go to the node of the first menu 
  1411. ;;;                                        item, etc., up to `9'
  1412.  
  1413. ;;; Go to first, second, third etc. menu item
  1414.  
  1415. (defun para-menu-1 ()
  1416.   "Go to the node of the first menu item."
  1417.   (interactive)
  1418.   (if (not (para-goto (para-menu-count 1)))
  1419.       (error "Node not found.")))
  1420.  
  1421. (defun para-menu-2 ()
  1422.   "Go to the node of the second menu item."
  1423.   (interactive)
  1424.   (if (not (para-goto (para-menu-count 2)))
  1425.       (error "Node not found.")))
  1426.  
  1427. (defun para-menu-3 ()
  1428.   "Go to the node of the third menu item."
  1429.   (interactive)
  1430.   (if (not (para-goto (para-menu-count 3)))
  1431.       (error "Node not found.")))
  1432.  
  1433. (defun para-menu-4 ()
  1434.   "Go to the node of the fourth menu item."
  1435.   (interactive)
  1436.   (if (not (para-goto (para-menu-count 4)))
  1437.       (error "Node not found.")))
  1438.  
  1439. (defun para-menu-5 ()
  1440.   "Go to the node of the fifth menu item."
  1441.   (interactive)
  1442.   (if (not (para-goto (para-menu-count 5)))
  1443.       (error "Node not found.")))
  1444.  
  1445. (defun para-menu-6 ()
  1446.   "Go to the node of the sixth menu item."
  1447.   (interactive)
  1448.   (if (not (para-goto (para-menu-count 6)))
  1449.       (error "Node not found.")))
  1450.  
  1451. (defun para-menu-7 ()
  1452.   "Go to the node of the seventh menu item."
  1453.   (interactive)
  1454.   (if (not (para-goto (para-menu-count 7)))
  1455.       (error "Node not found.")))
  1456.  
  1457. (defun para-menu-8 ()
  1458.   "Go to the node of the eighth menu item."
  1459.   (interactive)
  1460.   (if (not (para-goto (para-menu-count 8)))
  1461.       (error "Node not found.")))
  1462.  
  1463. (defun para-menu-9 ()
  1464.   "Go to the node of the ninth menu item."
  1465.   (interactive)
  1466.   (if (not (para-goto (para-menu-count 9)))
  1467.       (error "Node not found.")))
  1468.  
  1469. (defun para-menu-1x (count)
  1470.   "Go to the prompted for menu item number."
  1471.   (interactive "nMenu item #: ")
  1472.   (if (not (para-goto (para-menu-count count)))
  1473.       (error "Node not found.")))
  1474.  
  1475. (defun para-menu-count (count)
  1476.   (let (name)
  1477.     (save-excursion
  1478.       (goto-char (point-min))
  1479.       (or (search-forward "\n@menu" nil t)
  1480.           (error "No menu in this node"))
  1481.       (or  (re-search-forward "\n[ ]*\\* \\([^:\t\n]*\\):" nil t count)
  1482.            (error "Too few items in menu"))
  1483.       (beginning-of-line)
  1484.       (if (setq name (para-extract-menu-name 
  1485.                       (buffer-substring (match-beginning 1) (match-end 1))))
  1486.           name
  1487.         (error "Node not found.")))))
  1488.  
  1489.  
  1490. ;;; Display the first menu in a temporary buffer using `para-directory'
  1491. ;;; C-c C-p d     para-directory
  1492.  
  1493.  
  1494. (defvar para-main-menu-buffer-name ""
  1495.   "Temporary buffer used by `para-directory' for main menu.
  1496. Also, used by `para-xref' and `para-visited-xref' for cross reference
  1497. completion.")
  1498.  
  1499. (defun para-directory ()
  1500.   "Display the first menu in a temporary buffer.
  1501. Usually, the first menu is the master menu.
  1502.  
  1503. In this buffer,
  1504. \\<para-main-menu-buffer-mode-map>
  1505.  
  1506. `para-main-menu-goto-node' is bound to \\[para-main-menu-goto-node]
  1507.  
  1508. which will jump you to the prompted for node in the Para Mode file.
  1509. Default is the name of the node under the cursor.  Completion offered.
  1510.  
  1511. Also,
  1512.  
  1513. `para-main-menu-buffer-xref'  is bound to \\[para-main-menu-buffer-xref]
  1514.  
  1515. which inserts a Texinfo cross reference in the associated Para mode
  1516. file at the current position of point in the Para mode file.  Default
  1517. is the name of the node under the cursor.  With optional argument
  1518. \(prefix if interactive\), Emacs prompts you for a topic description.
  1519. Completion is offered, but only for node names listed in this
  1520. temporary buffer."
  1521.   
  1522.   (interactive)
  1523.   (setq para-current-buffer (current-buffer))
  1524.   (setq para-main-menu-buffer-name
  1525.         (concat para-main-menu-prefix (buffer-name) " "))
  1526.   (let (this-node
  1527.         (this-line 0))
  1528.     (save-excursion
  1529.       (save-restriction
  1530.         (widen)
  1531.         ;; Record current node name for later positioning in buffer.
  1532.         (end-of-line)
  1533.         (if (re-search-backward "^@node" nil t)
  1534.             (setq this-node (texinfo-copy-node-name))
  1535.           (setq this-node nil))
  1536.         (goto-char (point-min))
  1537.         (if (not (re-search-forward "^@menu"))
  1538.             (error "Menu not found!"))
  1539.         (forward-line 1)
  1540.         (let ((menu
  1541.                (buffer-substring
  1542.                 (point)
  1543.                 (save-excursion 
  1544.                   (if (not (re-search-forward "^@end menu" nil t))
  1545.                       (error "End of menu not found!"))
  1546.                   (beginning-of-line)
  1547.                   (point)))))
  1548.           
  1549.           (with-output-to-temp-buffer para-main-menu-buffer-name
  1550.             (set-buffer para-main-menu-buffer-name)
  1551.             (kill-all-local-variables)
  1552.             (set-syntax-table para-mode-syntax-table)
  1553.             (use-local-map para-main-menu-buffer-mode-map)
  1554.             
  1555.             (setq mode-name "Para Menu"
  1556.                   major-mode 'para-main-menu-buffer-mode)
  1557.             (insert menu)
  1558.             (setq buffer-read-only t)
  1559.             ;; create alist for completing-read
  1560.             (goto-char (point-min))
  1561.             (while (re-search-forward
  1562.                     "\n[ ]*\\* \\([^:\t\n]*\\):" nil t)
  1563.               ;; make a list,
  1564.               ;; each of element of which is \("name" . position\)
  1565.               (setq para-main-menu-completions-list
  1566.                     (cons (cons (buffer-substring
  1567.                                  (match-beginning 1)
  1568.                                  (match-end 1))
  1569.                                 (match-beginning 1))
  1570.                           para-main-menu-completions-list)))
  1571.             (goto-char (point-min))
  1572.             ))))
  1573.     (pop-to-buffer para-main-menu-buffer-name)
  1574.     (and this-node
  1575.          (re-search-forward this-node nil t) (beginning-of-line))))
  1576.  
  1577.  
  1578. ;;; Utility functions for displaying first menu
  1579.  
  1580. ;;; Includes commands to go to the node under the cursor and to insert
  1581. ;;; a cross reference in the source file refering to the node under
  1582. ;;; the cursor
  1583.  
  1584. (defvar para-main-menu-prefix "*Menu for: "
  1585.   "Prefix of name of temporary buffer displaying the main menu.")
  1586.  
  1587. (defvar para-main-menu-buffer-mode-map nil
  1588.   "Keymap used in temporary buffer displaying the main menu.")
  1589.  
  1590. ;;; !!! remove this setq after testing
  1591. (setq para-main-menu-buffer-mode-map nil)
  1592.  
  1593. (if para-main-menu-buffer-mode-map
  1594.     nil
  1595.   (setq para-main-menu-buffer-mode-map (copy-keymap text-mode-map))
  1596.   (define-key para-main-menu-buffer-mode-map "n"     'next-line)
  1597.   (define-key para-main-menu-buffer-mode-map " "     'next-line)
  1598.   (define-key para-main-menu-buffer-mode-map "p"     'previous-line)
  1599.   (define-key para-main-menu-buffer-mode-map "\177"  'previous-line)
  1600.   (define-key para-main-menu-buffer-mode-map "q"     
  1601.     '(lambda () "Bury current buffer; switch to current Para mode buffer."
  1602.        (interactive)
  1603.        (bury-buffer (current-buffer))
  1604.        (switch-to-buffer para-current-buffer)))
  1605.   (define-key para-main-menu-buffer-mode-map "\C-c\C-p\C-m"
  1606.     'para-main-menu-goto-node)
  1607.   (define-key para-main-menu-buffer-mode-map "m" 
  1608.     'para-main-menu-goto-node)
  1609.   (define-key para-main-menu-buffer-mode-map "\C-c\C-pr"
  1610.     'para-main-menu-buffer-xref)
  1611.   (define-key para-main-menu-buffer-mode-map "r"
  1612.     'para-main-menu-buffer-xref))
  1613.  
  1614. (defvar para-main-menu-completions-list nil
  1615. "List used by `para-main-menu-goto-node' for completions.")
  1616.  
  1617.  
  1618. ;;; Menu goto function for `para-directory'
  1619.  
  1620. ;;; !!! check whether this handles menus of form:
  1621. ;;;     * item:(filename)nodename.     description
  1622.  
  1623. (defun para-main-menu-goto-node (menu-item)
  1624.   "Go to the Para mode node prompted for; default is node under cursor.
  1625. Completion."
  1626.   (interactive
  1627.    (list
  1628.     (let ((default
  1629.             (save-excursion
  1630.               (beginning-of-line)
  1631.               (re-search-forward "\\* \\([^:\t\n]*\\):" nil t)
  1632.               (buffer-substring (match-beginning 1) (match-end 1))))
  1633.           item)
  1634.       (setq item (let ((completion-ignore-case t))
  1635.                    (completing-read (if default
  1636.                         (format "Node name (default %s): " default)
  1637.                       "Node name: ")
  1638.                     para-main-menu-completions-list nil t)))
  1639.       (if (string= item "") default item))))
  1640.   (let ((file-name (para-extract-menu-file-name))
  1641.         (node-name (para-extract-menu-name menu-item)))
  1642.     (pop-to-buffer (get-file-buffer file-name))
  1643.     (if (not (para-goto node-name))
  1644.         (error "Node not found: %s " node-name))))
  1645.  
  1646. (defun para-extract-menu-file-name ()
  1647.   "Return name of Para mode file for which this is the menu buffer."
  1648.   (let ((menu-file  (buffer-name)))
  1649.     (substring menu-file
  1650.              (progn (string-match para-main-menu-prefix menu-file)
  1651.                     (match-end 0)) -1)))
  1652.  
  1653.  
  1654. ;;; `para-directory'  cross reference insertion
  1655.  
  1656. (defun para-main-menu-buffer-xref
  1657.   (reference &optional topic-description)
  1658.   "Insert cross reference in Texinfo file to name of node under cursor.
  1659.  
  1660. The function inserts a Texinfo cross reference in the associated Para
  1661. mode file at the current position of point in the Para mode file.
  1662. Default is the name of the node under the cursor.  Completion.
  1663.  
  1664. Optional second arg is topic description; with prefix arg if
  1665. interactive, prompt for topic description."
  1666.   
  1667.   (interactive
  1668.     (let ((default
  1669.             (save-excursion
  1670.              (para-extract-menu-name 
  1671.               (progn
  1672.                (beginning-of-line)
  1673.                (re-search-forward "\\* \\([^:\t\n]*\\):" nil t)
  1674.                (buffer-substring (match-beginning 1) (match-end 1))))))
  1675.           (description "")
  1676.           node-name)
  1677.       (setq node-name 
  1678.             (let ((completion-ignore-case t))
  1679.               (completing-read
  1680.                (if default
  1681.                    (format "Node name (default %s): " default)
  1682.                  "Node name: ")
  1683.                para-main-menu-completions-list nil t)))
  1684.       (if (string= node-name "") (setq node-name default))
  1685.       (if current-prefix-arg
  1686.           (setq description
  1687.                 (read-string
  1688.                  "Topic description (end with RET): " 
  1689.                  (save-excursion
  1690.                    (goto-char (point-min))
  1691.                    (if (search-forward node-name nil t)
  1692.                        (para-main-menu-buffer-copy-description
  1693.                         (point-max)))))))
  1694.       (list node-name description)))
  1695.   (pop-to-buffer (get-file-buffer (para-extract-menu-file-name)))
  1696.   (if (string= "" topic-description)
  1697.       (insert (format "@xref{%s}." reference))
  1698.     (insert (format "@xref{%s, , %s}." reference topic-description))))
  1699.  
  1700. ;;; merge with texinfo-menu-copy-old-description 
  1701. ;;; this function handles the texinfo-master-menu-header
  1702. (defun para-main-menu-buffer-copy-description (end-of-menu)
  1703.  
  1704.   "Return description field of menu line as a string.
  1705. Point must be located on the same line before the description.  Point
  1706. left before description.  Single argument, END-OF-MENU, is position
  1707. limiting search."
  1708.   (skip-chars-forward "[:.,\t\n ]+")
  1709. ;  (re-search-forward ":[^:.,\t\n]*[:.,\t\n]+")
  1710.   ;; don't copy a carriage return at line beginning with asterisk!
  1711.   (if (and (looking-at "\\w+")    
  1712.            (not (looking-at
  1713.                  (concat 
  1714.                   "\\("
  1715.                   "^[ \t]\\* "          ; beginning of menu line
  1716.                   "\\|"
  1717.                   "^@end menu"          ; end of menu
  1718.                   "\\|"
  1719.                   texinfo-master-menu-header ; header line
  1720.                   "\\)"))))
  1721.       (buffer-substring
  1722.        (point)
  1723.        (save-excursion
  1724.          (if (not (if (re-search-forward 
  1725.                        (concat 
  1726.                         "\\("                ; beginning of menu line
  1727.                         "^[ \t]*\\* "        ; works with master directory
  1728.                         "\\|"
  1729.                         "^@end menu"         ; end of menu
  1730.                         "\\|"                ; text at beginning of line
  1731.                         "^\\w+"              ;  is usually not part of desc.
  1732.                         "\\|"
  1733.                         texinfo-master-menu-header ; header line
  1734.                         "\\)")
  1735.                        end-of-menu t)
  1736.                       (goto-char (match-beginning 1))))
  1737.              (goto-char end-of-menu))
  1738.          (forward-line -1)
  1739.          (while (looking-at "[ \t]*$")
  1740.            (forward-line -1))
  1741.          (end-of-line)                  ; go to end of last description line
  1742.          (point)))
  1743.     ""))
  1744.  
  1745.  
  1746. ;;; Utility functions to create indented menus
  1747.  
  1748. ;;; used by `para-make-master-menu'
  1749.  
  1750. (defun para-insert-indented-master-menu ()
  1751.   "Insert an indented master menu in the current buffer."
  1752.   (re-search-forward "^@menu")
  1753.   (beginning-of-line)
  1754.   (let* ((buffer-original-position (point))
  1755.          (master-menu (para-list-directory-list-menus-indentedly)))
  1756.     (goto-char buffer-original-position)
  1757.     ;; Delete existing menu; buffer must have ordinary top menu
  1758.     (delete-region (point)  
  1759.                    (save-excursion (re-search-forward "^@end menu") (point)))
  1760.     ;; Handle top of menu
  1761.     (insert "@menu\n")
  1762.     (while  (car master-menu)
  1763.       (insert (format "%s" (car master-menu)))
  1764.       (setq master-menu (cdr master-menu)))
  1765.     ;; Finish menu
  1766.     (insert "@end menu")))
  1767.  
  1768. (defun para-list-directory-list-menus-indentedly ()
  1769.   "List node names and descriptions as indented menu entries.
  1770. Must start after first menu.  Returns list of menu entries."
  1771.   (let ((master-directory-list))
  1772.     (while (re-search-forward "^@node" nil t)
  1773.       (beginning-of-line)
  1774.  
  1775.       (let ((spaces (para-list-directory-indent-spaces))
  1776.             (this-node (texinfo-copy-node-name)))
  1777.         (message "Getting menu entry for `%s' ... " this-node)
  1778.         (save-excursion
  1779.           (if (re-search-backward (concat "\\* " this-node ":") nil t)
  1780.               (setq master-directory-list
  1781.                     (cons
  1782.                      (concat
  1783.                       (para-list-directory-indent-spaces)
  1784.                       (para-list-directory-menu-entry))
  1785.                      master-directory-list))
  1786.             ;; else no menu entry
  1787.             )))
  1788.       (end-of-line))
  1789.     (nreverse master-directory-list)))
  1790.  
  1791. (defun para-list-directory-indent-spaces ()
  1792.   "Return a string of spaces according to level of menu."
  1793.   (cdr (assoc
  1794.         (texinfo-hierarchic-level)
  1795.        ;; Perhaps this alist should be a variable rather than written in.
  1796.        '(("chapter" . "")
  1797.          ("section" . "  ")
  1798.          ("subsection" . "    ")
  1799.          ("subsubsection" . "      ")))))
  1800.  
  1801. (defun para-list-directory-menu-entry ()
  1802.   "Return this menu entry, including description, as string.
  1803. Start at beginning of line."
  1804.   (buffer-substring (point)
  1805.                     (save-excursion
  1806.                       (end-of-line)
  1807.                       (re-search-forward
  1808.                        (concat
  1809.                         "\\(\\* \\([^:\t\n]*\\):"
  1810.                         "\\|^@end menu"
  1811.                         "\\|"
  1812.                         texinfo-master-menu-header
  1813.                         "\\)")
  1814.                         nil
  1815.                         t)
  1816.                       (goto-char (match-beginning 0))
  1817.                       (beginning-of-line)
  1818.                       (point))))
  1819.  
  1820.  
  1821. ;;; Display recently visited nodes in a temporary buffer
  1822.  
  1823. ;;; History of visited nodes; easy cross reference making
  1824.  
  1825. ;;; `para-list-visited-nodes' displays a list of the nodes you have
  1826. ;;; visited in the Para mode file, most recent first.  The nodes are
  1827. ;;; displayed in a temporary buffer.
  1828. ;;;
  1829. ;;; `para-goto-visited-node' jumps you to the prompted for node in the
  1830. ;;; Para Mode file.  Default is the name of the node under the cursor.
  1831. ;;; Completion."
  1832. ;;;
  1833. ;;; `para-visited-xref' inserts a cross reference in the current Para
  1834. ;;; mode buffer at point in that buffer. The default node name is the
  1835. ;;; name of the node under the cursor in the `*Recently Visited
  1836. ;;; Nodes*' buffer.  Completion offered for other node names, but only
  1837. ;;; for node names listed in the `*Recently Visited Nodes*' buffer
  1838. ;;; This function makes it easier to insert cross references,
  1839. ;;; expecially when you cannot readily remember the node names.
  1840. ;;;
  1841. ;;; With optional argument (prefix if interactive), Emacs prompts you
  1842. ;;; for a topic description.
  1843.  
  1844. ;;; Keybindings are:
  1845. ;;;
  1846. ;;; C-c C-p l       para-list-visited-nodes
  1847. ;;;
  1848. ;;; For bindings inside the temporary buffer created by
  1849. ;;; `para-list-visited-nodes', use
  1850. ;;;
  1851. ;;; C-c C-p r       para-visited-xref       (based on `para-xref')
  1852. ;;; C-c C-p C-m     para-goto-visited-node  (parallel to `para-menu')
  1853. ;;;
  1854. ;;;  (Note that the keybinding for `para-visited-xref' and
  1855. ;;;  `para-goto-visited-node' are defined locally in the temporary
  1856. ;;;  buffer, not in the para-mode-map.)
  1857.  
  1858. (defvar para-history nil
  1859.   "List of names of recently visited nodes.")
  1860.  
  1861. (defvar para-current-buffer nil
  1862.   "Current buffer in Para Mode.")
  1863.  
  1864. (defvar para-current-node nil
  1865.   "Current Para Mode node.")
  1866.  
  1867. (defvar para-list-visited-nodes-syntax-table nil)
  1868.  
  1869. (if para-list-visited-nodes-syntax-table nil
  1870.   (setq para-mode-syntax-table (make-syntax-table))
  1871.       (modify-syntax-entry ?\" "\"" para-list-visited-nodes-syntax-table))
  1872.  
  1873. (defvar para-list-visited-nodes-mode-map nil 
  1874. "Keymap used in node listing buffer in Para mode.")
  1875.  
  1876. ;;; !!! remove this setq after testing
  1877. (setq para-list-visited-nodes-mode-map nil)
  1878.  
  1879. (if para-list-visited-nodes-mode-map
  1880.     nil
  1881.   (setq para-list-visited-nodes-mode-map (copy-keymap text-mode-map))
  1882.   (define-key para-list-visited-nodes-mode-map "n"     'next-line)
  1883.   (define-key para-list-visited-nodes-mode-map " "     'next-line)
  1884.   (define-key para-list-visited-nodes-mode-map "p"     'previous-line)
  1885.   (define-key para-list-visited-nodes-mode-map "\177"  'previous-line)
  1886.   (define-key para-list-visited-nodes-mode-map "q"     
  1887.     '(lambda () "Bury current buffer; switch to current Para mode buffer."
  1888.        (interactive)
  1889.        (bury-buffer (current-buffer))
  1890.        (switch-to-buffer para-current-buffer)))
  1891.   (define-key para-list-visited-nodes-mode-map "\C-c\C-p\C-m"
  1892.     'para-goto-visited-node)
  1893.   (define-key para-list-visited-nodes-mode-map "m" 
  1894.     'para-goto-visited-node)
  1895.   (define-key para-list-visited-nodes-mode-map "\C-c\C-pr"
  1896.     'para-visited-xref)
  1897.   (define-key para-list-visited-nodes-mode-map "r"
  1898.     'para-visited-xref))
  1899.  
  1900.  
  1901. ;;; List recently visited nodes.
  1902. ;;; C-c C-p l       para-list-visited-nodes
  1903.  
  1904. (defun para-list-visited-nodes ()
  1905.   "Display a list of recently visited nodes in a temporary buffer.
  1906.  
  1907. In this buffer,
  1908. \\<para-list-visited-nodes-mode-map>
  1909.  
  1910. `para-visited-xref' is bound to \\[para-visited-xref]
  1911.  
  1912. which inserts a Texinfo cross reference in the associated Para mode
  1913. file at the current position of point in the Para mode file.  Default
  1914. is the name of the node under the cursor.  Completion is offered, but
  1915. only for node names listed in this temporary buffer.
  1916.  
  1917. With optional argument (prefix if interactive), Emacs prompts you
  1918. for a topic description.
  1919.  
  1920. `para-goto-visited-node' is bound to \\[para-goto-visited-node] 
  1921.  
  1922. which will jump you to the prompted for node in the Para Mode file.
  1923. Default is the name of the node under the cursor.  Completion offered."
  1924.  
  1925.   (interactive)
  1926.   (setq para-current-buffer (current-buffer))
  1927.  
  1928. ;;; para-history is set in para-last and para-goto
  1929.  
  1930.   (let ((visited-list para-history))
  1931.     (with-output-to-temp-buffer "*Recently Visited Nodes*"
  1932.       (pop-to-buffer "*Recently Visited Nodes*")
  1933.       (kill-all-local-variables)
  1934.       (use-local-map para-list-visited-nodes-mode-map)
  1935.       (setq mode-name ""
  1936.             major-mode 'para-list-visited-nodes-mode)
  1937.       (set-syntax-table para-mode-syntax-table)
  1938.       (while (car visited-list)
  1939.         (insert (format "\"%s\"\n"  (car visited-list)))
  1940.         (setq visited-list (cdr visited-list))))))
  1941.  
  1942. (defun para-goto-visited-node (node-name)
  1943.   "Go to the Para mode node prompted for; default is node under cursor.
  1944. Completion."
  1945. ;;; Format of recently visited nodes buffer is the following:
  1946. ;;; 
  1947. ;;; "Create Files and Nodes"
  1948. ;;; "Movement Commands"
  1949. ;;; "Shortcut Commands"
  1950. ;;; "Para Mode Commands"
  1951.   
  1952.   (interactive
  1953.    (let ((default 
  1954.            (save-excursion
  1955.              (beginning-of-line)
  1956.              (re-search-forward "^\"\\([^\"]+\\)\"$" nil t)
  1957.              (buffer-substring (match-beginning 1) (match-end 1))))
  1958.          (description "")
  1959.          completions)
  1960.      (save-excursion              ; create alist for completing-read
  1961.        (goto-char (point-min))
  1962.        (while (re-search-forward "^\"\\([^\"]+\\)\"$" nil t)
  1963.          ;; make a list each of element of which is \("name" . position\)
  1964.          (setq completions (cons (cons (buffer-substring
  1965.                                         (match-beginning 1)
  1966.                                         (match-end 1))
  1967.                                        (match-beginning 1))
  1968.                                  completions))))
  1969.      (setq node-name
  1970.            (let ((completion-ignore-case t))
  1971.              (completing-read
  1972.               (if default
  1973.                   (format "Node name (default %s): " default)
  1974.                 "Node name: ")
  1975.               completions nil t)))
  1976.      (if (string= node-name "") (setq node-name default))
  1977.      (list node-name)))
  1978.   (pop-to-buffer para-current-buffer)
  1979.   (if (not (para-goto node-name))
  1980.       (error "Node not found: %s " node-name)))
  1981.  
  1982. (defun para-visited-xref   (reference &optional topic-description)
  1983.   "Insert cross reference to node cursor is on in Texinfo file.
  1984.  
  1985. The function inserts a Texinfo cross reference in the associated Para
  1986. mode file at the current position of point in the Para mode file.
  1987. Default is the name of the node under the cursor.  Completion for
  1988. other node names listed in the buffer (not to all node names in source
  1989. file).
  1990.  
  1991. Optional second arg is topic description; with prefix arg if
  1992. interactive, prompt for topic description.
  1993.  
  1994. If temporary main menu buffer exists, default topic description is
  1995. description line in the menu.  (Type \\[para-directory] to generate a
  1996. main menu buffer if it does not exist.\)"
  1997.   
  1998. ;;; Format of recently visited nodes buffer is the following:
  1999. ;;; 
  2000. ;;; "Create Files and Nodes"
  2001. ;;; "Movement Commands"
  2002. ;;; "Shortcut Commands"
  2003. ;;; "Para Mode Commands"
  2004.   
  2005.   (interactive
  2006.    (let ((default 
  2007.            (save-excursion
  2008.              (beginning-of-line)
  2009.              (re-search-forward "^\"\\([^\"]+\\)\"$" nil t)
  2010.              (buffer-substring (match-beginning 1) (match-end 1))))
  2011.          (description "")
  2012.          completions
  2013.          node-name)
  2014.      (save-excursion              ; create alist for completing-read
  2015.        (goto-char (point-min))
  2016.        (while (re-search-forward "^\"\\([^\"]+\\)\"$" nil t)
  2017.          ;; make a list each of element of which is \("name" . position\)
  2018.          (setq completions (cons (cons (buffer-substring
  2019.                                         (match-beginning 1)
  2020.                                         (match-end 1))
  2021.                                        (match-beginning 1))
  2022.                                  completions))))
  2023.      (setq node-name
  2024.            (let ((completion-ignore-case t))
  2025.              (completing-read
  2026.               (if default
  2027.                   (format "Node name (default %s): " default)
  2028.                 "Node name: ")
  2029.               completions nil t)))
  2030.      (if (string= node-name "") (setq node-name default))
  2031.      (if current-prefix-arg
  2032.          (setq description
  2033.                (read-string
  2034.                 "Topic description (end with RET): " 
  2035.                 (if (get-buffer para-main-menu-buffer-name)
  2036.                     (save-excursion
  2037.                       (set-buffer para-main-menu-buffer-name)
  2038.                       (goto-char (point-min))
  2039.                       (if (search-forward node-name nil t)
  2040.                           (para-main-menu-buffer-copy-description
  2041.                            (point-max))))))))
  2042.      (list node-name description)))
  2043.   (pop-to-buffer para-current-buffer)
  2044.   (if (string= "" topic-description)
  2045.       (insert (format "@xref{%s}." reference))
  2046.     (insert (format "@xref{%s, , %s}." reference topic-description))))
  2047.  
  2048.  
  2049. ;;; Movement commands with `C-c C-p' prefix: top, next, prev, etc.
  2050.  
  2051. ;     C-c C-p C-b     para-beginning
  2052. ;     C-c C-p C-<     para-top-node
  2053. ;     C-c C-p C->     para-final
  2054.  
  2055. ;     C-c C-p C-u     para-up
  2056. ;     C-c C-p C-p     para-prev
  2057. ;     C-c C-p C-n     para-next
  2058.  
  2059. ;     C-c C-p C-[     para-goto-previous-node-in-sequence
  2060. ;     C-c C-p C-]     para-goto-next-node-in-sequence
  2061.  
  2062. ;     C-c C-p RET     para-menu
  2063. ;     C-c C-p C-l     para-last
  2064. ;     C-c C-p C-g     para-goto
  2065. ;     C-c C-p C-f     para-follow
  2066.  
  2067. ;;; Basic movement commands: top, next, prev, etc.
  2068.  
  2069. (defun para-beginning ()
  2070.   "Go to the very beginning of the file (before a `Top' node)."
  2071.   ;;; Does not handle include files.
  2072.   (interactive)
  2073.   (widen)
  2074.   (goto-char (point-min))
  2075.   (setq para-history
  2076.         (cons (save-excursion (para-extract-pointer 'next)) para-history)))
  2077.  
  2078. (defun para-top-node ()
  2079.   "Go to the `Top' node."
  2080.   (interactive)
  2081.   (if (not (para-goto "top"))
  2082.       (error "`Top' node not found.")))
  2083.  
  2084. (defun para-final ()
  2085.   "Go to the last node in the Para file."
  2086.   ;;; Does not handle include files.
  2087.   (interactive)
  2088.   (widen)
  2089.   (goto-char (point-max))
  2090.   (re-search-backward "^@node")
  2091.   (end-of-line)
  2092.   (para-narrow-to-node)
  2093.   (beginning-of-line)
  2094.   (setq para-history
  2095.         (cons (texinfo-copy-node-name)
  2096.               para-history)))
  2097.  
  2098. (defun para-up ()
  2099.   "Go to the superior node of this node."
  2100.   (interactive)
  2101.   (if (not (para-goto (para-extract-pointer 'up)))
  2102.       (error "`Up' node not found.")))
  2103.  
  2104. (defun para-prev (&optional arg)
  2105.   "Go to the previous node of this node.
  2106. With optional arg (prefix if interactive) go to the previous node in
  2107. sequence, regardless of its hierarcichal level or type."
  2108.   (interactive "P")
  2109.   (if arg
  2110.       (para-goto (para-previous-node-in-sequence))
  2111.     (if (not (para-goto (para-extract-pointer 'prev)))
  2112.         (error "`Previous' node not found."))))
  2113.  
  2114. (defun para-next (&optional arg)
  2115.   "Go to the next node of this node.
  2116. With optional arg (prefix if interactive) go to the next node in
  2117. sequence, regardless of its hierarcichal level or type."
  2118.   (interactive "P")
  2119.   (if arg
  2120.       (para-goto (para-next-node-in-sequence))
  2121.     (if (not (para-goto (para-extract-pointer 'next)))
  2122.       (error "`Next' node not found."))))
  2123.  
  2124. (defun para-last ()
  2125.   "Go back to the last node visited."
  2126.   (interactive)
  2127.   (or para-history
  2128.       (error "This is the first para node you looked at"))
  2129.   (let ((node-name (car (cdr para-history))))
  2130.     (if (para-goto node-name)
  2131.         (setq para-history (cdr (cdr para-history)))
  2132.       (error "Node not found: %s " node-name))))
  2133.  
  2134. (defun para-extract-pointer (next-prev-up)
  2135.   "Return name of   `Next', `Previous', or `Up' pointer as a string."
  2136.   ;; only argument `next-prev-up' is  'next, 'previous, or 'up
  2137.   (or (looking-at "^@node")
  2138.       (re-search-backward "^@node"  nil 'move-to-limit))
  2139.   (widen)
  2140.   (save-excursion
  2141.   ;; done this ugly way because of troubles with match-data when
  2142.   ;; trying to record all the matches for the next, prev and up
  2143.   ;; pointers and then using match-beginning and match-end to extract
  2144.   ;; desired name.
  2145.   (cond ((eq next-prev-up 'next) 
  2146.          (if (not (looking-at "^@node"))            ; not within a node
  2147.              (para-next-node-in-sequence)
  2148.            ;; else within a node
  2149.            ;; search for end of `next' nodename
  2150.            (if (re-search-forward (concat 
  2151.                                    "^@node"
  2152.                                    "[ \t]*[^,]*[ \t]*,"     
  2153.                                    "[ \t]*\\([^,]*\\)[ \t]*,") nil t)
  2154.                (buffer-substring
  2155.                 (match-beginning 1)
  2156.                 (progn (skip-chars-backward ", \t\n") (point)))
  2157.              ;; else
  2158.              (error "Next node not found!"))))
  2159.         
  2160.         ((eq next-prev-up 'prev) 
  2161.          ;; search for end of `previous' nodename
  2162.          (if (re-search-forward (concat 
  2163.                                  "^@node"
  2164.                                  "[ \t]*[^,]*[ \t]*,"               ; nodename
  2165.                                  "[ \t]*[^,]*[ \t]*,"               ; `Next' 
  2166.                                  "[ \t]*\\([^,]*\\)[ \t]*,") nil t) ; `Prev'
  2167.              (buffer-substring
  2168.               (match-beginning 1)
  2169.               (progn (skip-chars-backward ", \t\n") (point)))
  2170.            ;; else
  2171.            (error "Previous node not found!")))
  2172.         
  2173.         ((eq next-prev-up 'up) 
  2174.          ;; search for end of `up' nodename
  2175.          (if (re-search-forward (concat 
  2176.                                  "^@node"
  2177.                                  "[ \t]*[^,]*[ \t]*,"               ; nodename
  2178.                                  "[ \t]*[^,]*[ \t]*,"               ; `Next'
  2179.                                  "[ \t]*[^,]*[ \t]*,"               ; `Prev'
  2180.                                  "[ \t]*\\([^,\n]*\\)"              ; `Up'
  2181.                                  "[ \t]*$") nil t)
  2182.              (buffer-substring
  2183.               (match-beginning 1)
  2184.               (progn (skip-chars-backward ", \t\n") (point)))
  2185.            ;; else
  2186.            (error "Up node not found!"))))))
  2187.  
  2188. (defun para-goto-next-node-in-sequence ()
  2189.   "Go to the next node in buffer regardless of its hierarchical level.
  2190. This is an interface to the function `para-next-node-in-sequence'."
  2191.   (interactive)
  2192.   (para-goto (para-next-node-in-sequence)))
  2193.  
  2194. (defun para-goto-previous-node-in-sequence ()
  2195.   "Go to the previous node in buffer regardless of its hierarchical level.
  2196. This is an interface to the function `para-previous-node-in-sequence'."
  2197.   (interactive)
  2198.   (para-goto (para-previous-node-in-sequence)))
  2199.  
  2200. (defun para-follow (reference)
  2201.   "Follow REFERENCE to the node it refers to.
  2202. REFERENCE may include a filename or be an abbreviation of the reference name."
  2203.   (interactive
  2204.    (list
  2205.     (let ((default 
  2206.             (save-excursion
  2207.               (beginning-of-line)
  2208.               (if (re-search-forward  "@p?x?ref{[ \t]*\\([^,}]*\\)" nil t)
  2209.                   (buffer-substring (match-beginning 1) (match-end 1))
  2210.                 (error "No cross-reference in this node"))))
  2211.           completions
  2212.           nodename
  2213.           filename
  2214.           current-point
  2215.           i)
  2216.       (save-excursion
  2217.         (goto-char (point-min))
  2218.         (while
  2219.             ;; search for cross reference
  2220.             (re-search-forward "@p?x?ref{[ \t]*\\([^,}]*\\)" nil t)
  2221.           (setq current-point (point))
  2222.           (setq nodename
  2223.                 (buffer-substring
  2224.                  (match-beginning 1)
  2225.                  (progn (skip-chars-backward " \t\n") (point))))
  2226.           
  2227.           ;; remove extraneous characters from nodename string
  2228.           (while (setq i (string-match "[ \n\t]+" nodename i))
  2229.             (setq nodename (concat (substring nodename 0 i) " "
  2230.                                    (substring nodename (match-end 0))))
  2231.             (setq i (1+ i)))
  2232.           
  2233.           (skip-chars-forward " \t\n")
  2234.           (if (looking-at "}")        ; no filename entry
  2235.               (setq filename nil)
  2236.             ;; else not looking at a closing brace
  2237.             
  2238.             ;; possibilities:  is a two, three, four, or five entry xref
  2239.             ;; set up for search 
  2240.             (re-search-backward "@p?x?ref{" nil t)
  2241.             
  2242.             (cond (;; search for xref ending with second entry
  2243.                    (re-search-forward "@p?x?ref{[^,]*,[^,]*}" nil t)
  2244.                    (setq filename nil))
  2245.                   ;; search for xref ending with third entry
  2246.                   ((re-search-forward "@p?x?ref{[^,]*,[^,]*,[^,]*}" nil t)
  2247.                    (setq filename nil))
  2248.                   ;; search for xref ending with filename \(fourth entry\)
  2249.                   ((re-search-forward
  2250.                     "@p?x?ref{[^,]*,[^,]*,[^,]*,\\([^,]*\\)}" nil t)
  2251.                    (setq filename 
  2252.                          (buffer-substring
  2253.                           (progn
  2254.                             (goto-char (match-beginning 1))
  2255.                             (skip-chars-forward " \t\n")
  2256.                             (point))
  2257.                           (progn
  2258.                             (goto-char (match-end 1))
  2259.                             (skip-chars-forward " \t\n")
  2260.                             (point)))))
  2261.                   ;; else look for xref ending in manual name entry
  2262.                   ((re-search-forward
  2263.                     "@p?x?ref{[^,]*,[^,]*,[^,]*,\\([^,]*\\)\\(,[^,]+\\)}"
  2264.                     nil t)
  2265.                    (setq filename 
  2266.                          (buffer-substring
  2267.                           (progn
  2268.                             (goto-char (match-beginning 1))
  2269.                             (skip-chars-forward " \t\n")
  2270.                             (point))
  2271.                           (progn
  2272.                             (goto-char (match-end 1))
  2273.                             (skip-chars-forward " \t\n")
  2274.                             (point)))))
  2275.                   (t (setq filename nil))))
  2276.           (if (assoc nodename completions)
  2277.               nil
  2278.             (setq completions (cons (cons nodename filename) completions)))
  2279.           (goto-char current-point)))
  2280.       
  2281.  
  2282.       (cond (completions
  2283.              (let ((completion-ignore-case t))
  2284.                (setq reference
  2285.                      (completing-read
  2286.                       (if default
  2287.                           (format "Follow cross ref to (default %s): " default)
  2288.                         "Follow cross ref to: ") 
  2289.                       completions nil t)))
  2290.              (if (string= reference "") (setq reference default))
  2291.              
  2292.              (if (cdr (assoc reference completions))
  2293.                  (setq filename
  2294.                        (read-from-minibuffer
  2295.                         "Go to cross reference in file: "
  2296.                         (cdr (assoc reference completions))))))
  2297.  
  2298.             (t (error "No cross-reference in this node")))
  2299.       (and filename (setq filename (concat "(" filename ")")))
  2300.       (concat filename reference))))
  2301.  
  2302.   (para-goto reference))
  2303.  
  2304.  
  2305. ;;; Regular Expression Search 
  2306.  
  2307. (defvar para-last-search nil
  2308.   "Default regexp for para-search command to search for.")
  2309.  
  2310. (defun para-search (regexp)
  2311.   "Search for REGEXP, starting from point, and select node it's found in."
  2312.   (interactive "sSearch (regexp): ")
  2313.   (if (equal regexp "")
  2314.       (setq regexp para-last-search)
  2315.     (setq para-last-search regexp))
  2316.   
  2317.   (let ((this-node para-current-node)
  2318.     found)
  2319.     (save-excursion
  2320.       (save-restriction
  2321.     (widen)
  2322.     (re-search-forward regexp)
  2323.     (setq found (point))))
  2324.     (widen)
  2325.     (goto-char found)
  2326.     (para-narrow-to-node)
  2327.     ;; para-narrow-to-node specifies value of para-current-node
  2328.     (or (equal this-node para-current-node)
  2329.         (setq para-history (cons para-current-node para-history)))
  2330.     (para-set-mode-line)))
  2331.  
  2332.  
  2333. ;;; Name of next or previous node in strict sequence
  2334.  
  2335. (defun para-next-node-in-sequence ()
  2336.   "Return name of next node in buffer regardless of its hierarchical level."
  2337.   (interactive)
  2338.   (widen)
  2339.   (end-of-line) ; to skip past `@node' at beginning of node.
  2340.   (if (not (re-search-forward "^@node" nil t))
  2341.       (progn (beginning-of-line)
  2342.              (para-narrow-to-node)
  2343.              (error "Next node not found!"))
  2344.     (beginning-of-line)
  2345.     (let ((nodename (texinfo-copy-node-name)))
  2346.       (or nodename
  2347.           (error "No node name found for Next node!")))))
  2348.  
  2349. (defun para-previous-node-in-sequence ()
  2350.   "Go to the previous node in buffer regardless of its hierarchical level."
  2351.   (interactive)
  2352.   (para-narrow-to-node)  ; so back search is not stuck at current node
  2353.   (goto-char (point-min))
  2354.   (widen)
  2355.   (if (not (re-search-backward "^@node" nil t))
  2356.       (progn (beginning-of-line)
  2357.              (para-narrow-to-node)
  2358.              (error "Previous node not found!"))
  2359.     (let ((nodename (texinfo-copy-node-name)))
  2360.       (or nodename
  2361.           (error "No node name found for Previous node!")))))
  2362.  
  2363.  
  2364. ;;; Single keystroke Info commands
  2365.  
  2366. (defun para-@ (key)
  2367.   "Provide Info-like commands when point in upper-left or buffer read-only.
  2368. In a writable buffer when point is not in the upper-left corner, keys 
  2369. self-insert."
  2370.   (interactive "p")
  2371.   (if (and (not buffer-read-only)
  2372.            (pos-visible-in-window-p (1- (point))))
  2373.       (progn
  2374.         (self-insert-command key)
  2375.         (if (<= fill-column (current-column))
  2376.             (if auto-fill-hook
  2377.                 (funcall auto-fill-hook)
  2378.               nil)))
  2379.     
  2380.     (let* ((this-key (aref (this-command-keys) 0)))
  2381.       (call-interactively
  2382.        (cond ((= this-key ?g)    'para-goto-node)
  2383.              ((= this-key ?<)    'para-top-node)
  2384.              ((= this-key ?>)    'para-final)
  2385.              ((= this-key ?\[)   'para-goto-previous-node-in-sequence)
  2386.              ((= this-key ?\])   'para-goto-next-node-in-sequence)
  2387.              ((= this-key ? )    'para-scroll-up)
  2388.          ((= this-key ?\^?)  'para-scroll-down)
  2389.              ((and (<= ?0 this-key) (<= this-key ?9))
  2390.               (cdr (assoc
  2391.                     this-key
  2392.                     (cdr (assoc 16  (cdr (assoc 3 para-mode-map)))))))
  2393.              (t (cdr (assoc
  2394.                       (- this-key ?`)
  2395.                       (cdr (assoc 16 (cdr (assoc 3 para-mode-map))))))))))))
  2396.  
  2397. (defun para-scroll-up (arg)
  2398.   "Scroll text of current window upward ARG lines.
  2399. Keep point in same relative position in window."
  2400.   (interactive "P")
  2401.   (let ((current-relative-position (- (window-point) (window-start))))
  2402.     (scroll-up arg)
  2403.     (goto-char (+ (window-start) current-relative-position))))
  2404.  
  2405. (defun para-scroll-down (arg)
  2406.   "Scroll text of current window downward ARG lines.
  2407. Keep point in same relative position in window."
  2408.   (interactive "P")
  2409.   (let ((current-relative-position (- (window-point) (window-start))))
  2410.     (scroll-down arg)
  2411.     (goto-char (+ (window-start) current-relative-position))))
  2412.  
  2413.  
  2414. ;;; Index entry commands:  @cindex, @findex, etc.
  2415.  
  2416. ;; Must redefine each index command to use `para-index' since
  2417. ;; `texinfo-index' deletes the index line after reading it.
  2418. ;; Hence the lack of shared code.
  2419.  
  2420. (put 'vindex 'para-format 'para-format-vindex)
  2421. (defun para-format-vindex () (para-index 'para-vindex))
  2422.  
  2423. (put 'cindex 'para-format 'para-format-cindex)
  2424. (defun para-format-cindex () (para-index 'para-cindex))
  2425.  
  2426. (put 'findex 'para-format 'para-format-findex)
  2427. (defun para-format-findex () (para-index 'para-findex))
  2428.  
  2429. (put 'pindex 'para-format 'para-format-pindex)
  2430. (defun para-format-pindex () (para-index 'para-pindex))
  2431.  
  2432. (put 'tindex 'para-format 'para-format-tindex)
  2433. (defun para-format-tindex () (para-index 'para-tindex))
  2434.  
  2435. (put 'kindex 'para-format 'para-format-kindex)
  2436. (defun para-format-kindex () (para-index 'para-kindex))
  2437.  
  2438. (defun para-index (indexvar)
  2439.   (let ((arg (texinfo-parse-expanded-arg)))
  2440.     (set indexvar
  2441.      (cons (list arg (para-current-node))
  2442.            (symbol-value indexvar)))))
  2443.  
  2444. (defconst para-indexvar-alist
  2445.   '(("cp" . para-cindex)
  2446.     ("fn" . para-findex)
  2447.     ("vr" . para-vindex)
  2448.     ("tp" . para-tindex)
  2449.     ("pg" . para-pindex)
  2450.     ("ky" . para-kindex)))
  2451.  
  2452.  
  2453. ;;; Define indices:  @defindex   @defcodeindex
  2454.  
  2455. (put 'defindex 'para-format 'para-format-defindex)
  2456. (put 'defcodeindex 'para-format 'para-format-defindex)
  2457. (defun para-format-defindex ()
  2458.   (let* ((index-name (texinfo-parse-line-arg)) ; eg: `aa'
  2459.          (indexing-command (intern (concat index-name "index")))
  2460.          (index-formatting-command      ; eg: `para-format-aaindex'
  2461.           (intern (concat "para-format-" index-name "index")))
  2462.          (index-alist-name              ; eg: `para-aaindex'
  2463.           (intern (concat "para-" index-name "index"))))
  2464.  
  2465.     (set index-alist-name nil)
  2466.  
  2467.     (put indexing-command               ; eg, aaindex
  2468.          'para-format
  2469.          index-formatting-command)      ; eg, para-format-aaindex
  2470.  
  2471.     ;; eg: "aa" . para-aaindex
  2472.     (or (assoc index-name para-indexvar-alist)
  2473.         (setq para-indexvar-alist
  2474.               (cons
  2475.                (cons index-name
  2476.                      index-alist-name)
  2477.                para-indexvar-alist)))
  2478.  
  2479.     (fset index-formatting-command
  2480.           (list 'lambda 'nil
  2481.                 (list 'para-index 
  2482.                       (list 'quote index-alist-name))))))
  2483.  
  2484.  
  2485. ;;; Merge indices: @synindex   @syncodeindex
  2486.  
  2487. (put 'synindex 'para-format 'para-format-synindex)
  2488. (put 'syncodeindex 'para-format 'para-format-synindex)
  2489.  
  2490. (defun para-format-synindex ()
  2491.   (let* ((args (texinfo-parse-line-arg))
  2492.          (second (cdr (read-from-string args)))
  2493.          (joiner (symbol-name (car (read-from-string args))))
  2494.          (joined (symbol-name (car (read-from-string args second)))))
  2495.  
  2496.     (if (assoc joiner para-short-index-cmds-alist)
  2497.         (put
  2498.           (cdr (assoc joiner para-short-index-cmds-alist))
  2499.          'para-format
  2500.          (or (cdr (assoc joined para-short-index-format-cmds-alist))
  2501.              (intern (concat "para-format-" joined "index"))))
  2502.       (put
  2503.        (intern (concat joiner "index"))
  2504.        'para-format
  2505.        (or (cdr(assoc joined para-short-index-format-cmds-alist))
  2506.            (intern (concat "para-format-" joined "index")))))))
  2507.  
  2508. (defconst para-short-index-cmds-alist
  2509.   '(("cp" . cindex)
  2510.     ("fn" . findex)
  2511.     ("vr" . vindex)
  2512.     ("tp" . tindex)
  2513.     ("pg" . pindex)
  2514.     ("ky" . kindex)))
  2515.  
  2516. (defconst para-short-index-format-cmds-alist
  2517.   '(("cp" . para-format-cindex)
  2518.     ("fn" . para-format-findex)
  2519.     ("vr" . para-format-vindex)
  2520.     ("tp" . para-format-tindex)
  2521.     ("pg" . para-format-pindex)
  2522.     ("ky" . para-format-kindex)))
  2523.  
  2524.  
  2525. ;;; Print index: @printindex
  2526.  
  2527. (put 'printindex 'para-format 'para-format-printindex)
  2528.  
  2529. (defun para-format-printindex ()
  2530.   (let ((indexelts (symbol-value
  2531.             (cdr (assoc (texinfo-parse-line-arg)
  2532.                 para-indexvar-alist))))
  2533.     opoint)
  2534.     (insert "\n@ignore\n* Menu:\n\n")
  2535.     (setq opoint (point))
  2536.     (para-print-index nil indexelts)
  2537.  
  2538.     (if (eq system-type 'vax-vms)
  2539.         (texinfo-sort-region opoint (point))
  2540.       (shell-command-on-region opoint (point) "sort -fd" 1))
  2541.         (insert "\n@end ignore\n")))
  2542.  
  2543. (defun para-print-index (file indexelts)
  2544.   (while indexelts
  2545.     (if (stringp (car (car indexelts)))
  2546.     (insert "* " (car (car indexelts))
  2547.         ": " (if file (concat "(" file ")") "")
  2548.         (nth 1 (car indexelts)) ".\n")
  2549.       ;; index entries from @include'd file
  2550.       (para-print-index (nth 1 (car indexelts))
  2551.                (nth 2 (car indexelts))))
  2552.     (setq indexelts (cdr indexelts))))
  2553.  
  2554.  
  2555. ;;; Insert index into Para mode file (interactive command)
  2556.  
  2557. (defun para-insert-index ()
  2558.   "Insert index at @printindex command in Para mode file."
  2559.   (interactive)
  2560.   (require 'texinfmt)
  2561.   (widen)
  2562.   (let (para-command-name
  2563.         texinfo-command-start
  2564.         texinfo-command-end
  2565.         texinfo-last-node               ; Texinfo mode variable
  2566.         para-vindex
  2567.         para-findex
  2568.         para-cindex
  2569.         para-pindex
  2570.         para-tindex
  2571.         para-kindex)
  2572.     
  2573.     (goto-char (point-min))
  2574.     (while (re-search-forward "^@\\w+index" nil t)
  2575.       (forward-word -1)
  2576.       ;; @ is followed by a command-word; find the end of the word.
  2577.       (setq texinfo-command-start (point))
  2578.       (forward-word 1)
  2579.       (setq texinfo-command-end (point))
  2580.       ;; Call the handler for this command.
  2581.       (setq para-command-name
  2582.             (intern (buffer-substring texinfo-command-start
  2583.                                       texinfo-command-end)))
  2584.       (let ((cmd (get para-command-name 'para-format)))
  2585.         (if cmd (funcall cmd)
  2586.           (error "Para mode cannot handle \"%s\"."
  2587.                  (buffer-substring
  2588.                   texinfo-command-start 
  2589.                   texinfo-command-end)))))))
  2590.  
  2591.  
  2592. ;;; Create index entries (interactive commands)
  2593.  
  2594. (defun para-index-function (function &optional where)
  2595.   "Insert entry for function index at end of paragraph.
  2596. Interactively, offer first symbol following point within paragraph
  2597. that is enclosed by braces of @code command.  With prefix arg, insert
  2598. entry at point \(no default offered\)."
  2599.   (interactive (para-index-what-and-where-utility))
  2600.   (if (eq where 'end-para)  (forward-paragraph 1))
  2601.   (insert "@findex " function "\n"))
  2602.  
  2603. (defun para-index-variable (variable &optional where)
  2604.   "Insert entry for variable index at end of paragraph.
  2605. Interactively, offer first symbol following point within paragraph
  2606. that is enclosed by braces of @code command.  With prefix arg, insert
  2607. entry at point \(no default offered\)."
  2608.  
  2609.   (interactive (para-index-what-and-where-utility))
  2610.   (if (eq where 'end-para)  (forward-paragraph 1))
  2611.     (insert "@vindex " variable "\n"))
  2612.  
  2613. (defun para-index-program (program &optional where)
  2614.   "Insert entry for program index at end of paragraph.
  2615. Interactively, offer first symbol following point within paragraph
  2616. that is enclosed by braces of @code command.  With prefix arg, insert
  2617. entry at point \(no default offered\)."
  2618.   
  2619.   (interactive (para-index-what-and-where-utility))
  2620.   (if (eq where 'end-para)  (forward-paragraph 1))
  2621.   (insert "@pindex " program "\n"))
  2622.  
  2623. (defun para-index-datatype (datatype &optional where)
  2624.   "Insert entry for datatype index at end of paragraph.
  2625. Interactively, offer first symbol following point within paragraph
  2626. that is enclosed by braces of @code command.  With prefix arg, insert
  2627. entry at point \(no default offered\)."
  2628.   
  2629.   (interactive (para-index-what-and-where-utility))
  2630.   (if (eq where 'end-para)  (forward-paragraph 1))
  2631.   (insert "@tindex " program "\n"))
  2632.  
  2633. (defun para-index-keystroke (keystrokes &optional where)
  2634.   "Insert entry for keystroke index at end of paragraph.
  2635. Interactively, offer default:
  2636.  
  2637.     1. If point is at beginning of an @item or @itemx line,
  2638.        offer rest of that line.
  2639.  
  2640.     2. Else, offer first symbol following point within paragraph
  2641.        that is enclosed by braces of @kbd command.
  2642.  
  2643. With prefix arg, insert entry at point \(no default offered\)."
  2644.   
  2645.   (interactive
  2646.    (let (keystrokes where)
  2647.      (if current-prefix-arg
  2648.          (setq keystrokes (read-from-minibuffer "Keystrokes: ")
  2649.                where 'here)
  2650.        (let((default-keystrokes
  2651.               (if (looking-at "@itemx? \\(.*\\)$")
  2652.                   (buffer-substring (match-beginning 1) (match-end 1))
  2653.                 
  2654.                 (if (re-search-forward "@kbd\\s(\\(\\S)+\\)\\s)")
  2655.                     (buffer-substring (match-beginning 1) (match-end 1))
  2656.                   ""))))
  2657.          
  2658.          (setq keystrokes
  2659.                (read-from-minibuffer 
  2660.                 "Keystrokes: "
  2661.                 (if default-keystrokes default-keystrokes ""))
  2662.                where 'end-para)))
  2663.      
  2664.      (list keystrokes where)))
  2665.   (if (eq where 'end-para)  (forward-paragraph 1))
  2666.   (insert "@kindex " keystrokes "\n"))
  2667.  
  2668. (defun para-index-concept (concept &optional where)
  2669.   "Insert entry for concept index at end of paragraph.
  2670. Offer word following point as default; with numeric prefix arg, offer
  2671. that many words following point as default.  With prefix arg (not a
  2672. numeric prefix arg), insert entry at point \(no default offered\).
  2673. Non-interactively, first arg CONCEPT is string; optional second arg
  2674. WHERE is either symbol 'here or symbol 'end-para."
  2675.  
  2676.   (interactive
  2677.    (let (concept where how-many)
  2678.      (cond ((and (listp current-prefix-arg)
  2679.                  (eq 4 (prefix-numeric-value current-prefix-arg)))
  2680.             (setq where 'here))
  2681.            ((prefix-numeric-value current-prefix-arg) 
  2682.             (setq how-many (prefix-numeric-value current-prefix-arg)
  2683.                   where 'end-para))
  2684.            (t (setq how-many 1 where 'end-para)))
  2685.      (if (eq where 'end-para)
  2686.          (let((default-concept
  2687.                 (buffer-substring
  2688.                  (save-excursion (skip-chars-forward " \t") (point))
  2689.                  (save-excursion (forward-word how-many) (point)))))
  2690.            (setq concept (read-from-minibuffer 
  2691.                           "Concept: " (if default-concept default-concept
  2692.                                         ""))))
  2693.        (setq concept (read-from-minibuffer 
  2694.                       "Concept: ")))
  2695.      (list concept where)))
  2696.   
  2697.   (if (eq where 'end-para)  (forward-paragraph 1))
  2698.   (insert "@cindex " concept "\n"))
  2699.  
  2700.  
  2701. ;;; Index utility functions
  2702. ;;; para-current-node, para-index-what-and-where-utility 
  2703.  
  2704. (defun para-current-node ()
  2705.   "Return name of current node at or preceding point."
  2706.   (save-excursion
  2707.     (if (or (looking-at "^@node")
  2708.             (re-search-backward "^@node"  nil 'move-to-limit))
  2709.         ;; point is within a node
  2710.         (progn
  2711.           (re-search-forward "@node[ \t]*\\<\\([^,]*\\),")
  2712.           (buffer-substring (match-beginning 1) (match-end 1)))
  2713.       ;; else node not found
  2714.       (error "Node not found."))))
  2715.  
  2716. (defun para-index-what-and-where-utility ()
  2717.   "Utility used by para-index-function and others."
  2718.   (let (what where)
  2719.     (if current-prefix-arg
  2720.         (setq what (read-from-minibuffer "Entry: ")
  2721.               where 'here)
  2722.       (let((default-what
  2723.              (if (re-search-forward
  2724.                   "@code\\s(\\(\\S)+\\)\\s)"
  2725.                   (save-excursion (forward-paragraph 1) (point))
  2726.                   t)
  2727.                  (buffer-substring
  2728.                   (match-beginning 1) (match-end 1)))))
  2729.         (setq what (read-from-minibuffer 
  2730.                         "Entry: " (if default-what default-what ""))
  2731.                where 'end-para)))
  2732.     (list what where)))
  2733.  
  2734.  
  2735. (message "Loading Para mode ... done ")
  2736. (provide 'para)
  2737.  
  2738.  
  2739.  
  2740. ;;; Bob only: site specific key rebinding
  2741.  
  2742. ; `C-c C-x' is the prefix key for Para indexing.
  2743. ; Redefine para-mode-map to use control keys in order to avoid
  2744. ; conflict with Bob's keybindings for edebug.
  2745.  
  2746. (define-key para-mode-map "\C-c\C-x\C-c" 'para-index-concept)
  2747. (define-key para-mode-map "\C-c\C-x\C-f" 'para-index-function)
  2748. (define-key para-mode-map "\C-c\C-x\C-k" 'para-index-keystroke)
  2749. (define-key para-mode-map "\C-c\C-x\C-p" 'para-index-program)
  2750. (define-key para-mode-map "\C-c\C-x\C-t" 'para-index-datatype)
  2751. (define-key para-mode-map "\C-c\C-x\C-v" 'para-index-variable)
  2752.  
  2753. (define-key para-mode-map "\C-c\C-x\C-x" 'para-insert-index)